Tag Archives: #noestimates

Why I decided to quit #NoEstimates


#NoEstimates is essentially a twitter hashtag, as I already mentioned in a previous post. In this post from late 2014, I tried to explain my point of view on both the #NoEstimates hashtag and the reasons why I think we should try as much as possible to find other ways than estimates in order to make decisions.

Today, I decided to stop using #NoEstimates as a hashtag, and the purpose of this post is basically to explain why.

The best I could find to summarize my thoughts right now is this tweet of mine :


When I first heard of #NoEstimates, I was the leader of a small development team, using Kanban in quite a Lean fashion. The team was not really involved in estimating potential value or cost, or even effort; so that the only thing business was asking from us was delivery date estimations.

As I explained in “Indian Planning Poker”, we first tried to use effort estimates – the Agile way – to deduce delivery dates. That proved completely useless and a big waste of time. Since we were in a Lean state of mind, we decided to drop all those wasteful estimation stuff and use a simple rule : slice it until it is small enough to be “as usual”. This would be sufficient to enable statistical forecasting : not every work item would be the same size, but their size would follow a distribution that we could use.

In Kanban we want things to be as much business as usual as possible. The standard, Kanban, way to operate is to identify several classes of service, for example based on their cost of delay, and make sure we “modelize” their cycle time distribution. To be clear : the heuristics we use for determining cost of delay and slicing work items are definitely some kind of effort/risk/complexity/cost estimation.

My first blog on the #NoEstimates topic was a rant against standard Agile, velocity-driven estimation. There is something I don’t get with this story point, velocity thing, really. At that time I thought that #NoEstimates meant exactly “no fucking story point estimates, use data and statistics for fuck’s sake”. I was then – I still am – a pretty big fan of people like Pawel Brodzinski and Troy Magennis.


While I was stepping into the #NoEstimates world, I realized that some of the most important thought leaders behind the hashtag were sharing my views on budget-driven development, what I called post-agile. In fact I realized later that it was just “Agile” – not post-Agile. Anyway.

Product development became a main focus. Lean startup, story maps, impact maps, “job to be done” are the kind of stuff I got into. I really believe in product discovery and learning. My main thought here is : do not estimate outcome, try and learn. Learning might involve estimation though.


When I started tweeting with the #NoEstimates hashtag, I wanted to say something like “Hello! We don’t use effort estimates here. Come around, I’ll tell you how if you wish”, but that did not happen. What happened was that #NoEstimates was actually a minefield. I immediately had to answer things like “Give me a real example of a multi-billion project done without any kind of estimates”. Ouch. “Please reply to the 5 blog posts I wrote against #NoEstimates”. Hum…

I tried. I genuinely tried to answer, given my knowledge and experience. But it seems like I failed. I had pretty interesting conversations though.


But #NoEstimates comes with a huge load of emotions. Time passing, I noticed that most of the conversations around #NoEstimates were very superficial. I got involved in a couple of them myself. On the topic of #NoEstimates you can find conversations about linguistic, semantic, how to behave politely, etc. and all of this comes and comes again without any hope for improvement.

I really got frustrated and wrote an open letter to try and understand why #NoEstimates was that dangerous, why there was so much hatred, on so little details, in vain. I saw many people, including myself, try to explain that not all estimates are to be removed, that obviously we knew that we basically estimate all the time in our day-to-day life, in vain too. Neil Killick, who recently got involded in a pure semantic argument, also tried to sort this all out, in vain again.

The thing is that this hashtag is bad, too extreme maybe. I’ve seen it described as a tribe, with some revolutionary connotation. The truth is  we should have settled the semantic discussions a long time ago. Instead :

If we want to move forward on this topic, I think we need to stop using the #NoEstimates hashtag. When I’ll come to twitter to talk about estimates, I won’t hashtag #NoEstimates anymore. Estimates are just a tool. There is always a bigger purpose and we should talk about it instead. Are we talking about #ReleasePlanning ? Is it #ProductDevelopment ?Estimates are a vehicle, not a target. Let’s move forward and talk about the real things.

Ravings on #NoEstimates

In this probably too long post I will try to expose my thoughts on #NoEstimates as I see it. I will also try to give some pieces of answer to the most recurring questions and critics exposed by #NoEstimates opposition.


#NoEstimates is by essence a twitter thing… and this is a plague, really. I’ve been reading many, and participating in some, #NoEstimates twitter conversations, and what really hit me is how much it is difficult to have a built conversation within 140 characters. It especially is with #NoEstimates because of an obvious vocabulary issue in the very definition of what an estimate is, and how much it differs from a forecast for example. I am convinced that many arguments about estimates would not have occurred if people would have first worked on a kind of “mutual understanding”.

So, for the record, and in order to make future conversations with me easier, I consider estimating as very different from forecasting in the sense that forecasting uses data to predict the future, usually with statistics and probabilities, while estimation is more based on experience and is more “vague”… but that’s only my definition and you may very well disagree. We just need to know what we are talking about before we start fighting.

Not doing estimates existed way before #NoEstimates

The first story I heard (read) of was the one of Dragos Dumitriu, as described by David J. Anderson in “Kanban : Successful Evolutionary Change for Your Technology Business”. This story dates back to 2004. There are of course many other “old” stories like this one, including from people in the anti-#NoEstimates side (I’m thinking of Trevor K. Nelson here).

What is important is that although the hashtag is rather new, the question is pretty old. This also means that Woody Zuill’s point of view (he initiated #NoEstimates as a hashtag for those who don’t know) has nothing to do with a dogma or anything of this kind. I find it’s a shame to read sometimes things like “zealotry” or “evangelical” when talking about #NoEstimates. People who wants to talk about not/less using estimates in software development can use this hashtag. Period. Woody Zuill has his own view, others have other views, no “absolute” here. #NoEstimates is neither a movement nor a religion.

Common sense

I am paraphrasing Peter Kretzman here, but I genuinely think that trying to get rid of estimates is pure common sense and I will try to explain this as much as possible.


The first thing that comes to mind is that estimates do not produce concrete value. That makes them a waste in the sense of Lean. It seems logical, if you follow this paradigm, to try to get rid of them when possible.

only a tool

“[Estimates are] a tool, not an outcome” (Peter Kretzman, The case against #NoEstimates, part 3: NoEstimates arguments and their weaknesses). I agree with that. One of the main critics anti- have against #NoEstimates is “Don’t blame the tool because you don’t know how to use it”, and this argument is a bit flawed in my opinion : let’s abstract away “estimates” one moment and talk about a random tool instead. So let’s say we have a tool. This tool have proved useful many times but it appears that many people fail to use it correctly. This tool is intrinsically dangerous when not correctly used. Often it is so much misused that it can jeopardize the whole project, or the whole company. Facing with this situation in his company one can either

  • Make the tool easier to use, which means change the tool, so that people can use it correctly
  • Train people in the tool, so that they eventually manage to use it correctly. The “don’t blame the tool” critic live here.
  • Find another tool that would do the same, or better, and would be easier to use
  • See if we could completely get rid of the tool, maybe by changing the very problem the tool is designed to tackle

#NoEstimates is about the last two points, or a combination of both :

  • some of the #NoEstimates advocates seek to find ways to remove estimates as much as possible and replace them when needed by forecasting based on actual data and statistics. A very common practice in the Lean/Kanban world.
  • others – or the same actually – believe that by changing the business relationship we could completely remove the need of providing any kind of future prediction. Hence no estimates at all. Some relationships are more difficult to change than others though, and of course internal software development with fixed time and budget (“own money”) would be easier to do with no estimates than a fixed- scoped public-procurement based projects…

obvious in certain situations

There are domains where estimations are often not used at all, in nowadays’ software business. Unsorted : very urgent operations, fixed-budget fixed-time research and development, fixed-time options testing (UI design testing with prototypes for examples). You can figure some more situations I am sure.

We all agree !

Maybe the main thought I have about #NoEstimates, and it will be my conclusion, is that most of the #NoEstimates folk agree with most anti-#NoEstimates people. Unfortunately some barriers exist and it is our duty to try and break them so that the discussion go a step further. That is the goal of my Open letter to anti-#NoEstimates people.


Open letter to anti-#NoEstimates people

Dear Peter, Glen, Trevor…and friends,

As some of you might already know, I’ve been hanging around in the #NoEstimates hashtag for quite some time. Even before that, before I even noticed that there was a hashtag, I and my team had been practicing a less-no-better-fewer-leaner-estimates kind of software development.

To sum it up, my story is basically that, in a context of co-called “Agile” software development, I was not comfortable with how estimates were done (the whole poker planning thing). Instead of trying to improve our estimation process, to make it more accurate and reliable, which is a path I respect, I, in a Lean-minded attempt, tried to remove estimates as much as possible and use historical data instead. I know that there is a recurring discussion out there about the very definition of what an “estimate” is and the difference there is between “estimate” and “forecast”. Honestly, although this discussion drives – consumes – a big part of the whole #NoEstimates thing, I don’t care much.

Ever since I began to read things about #NoEstimates, on twitter or elsewhere, I keep asking myself the same question. I might already have tried here and there to talk about it. Maybe I sometimes was a bit too vehement (euphemism), which may or may not explain why I still haven’t found The Answer. That is why I’m writing this open letter.

So my question to you is very simple :

Why do you even care about #NoEstimates ?

#NoEstimates is a hashtag where people who want to try to do software development business without estimates gather and talk together. To be precise I should write “do their software development business”. What I am meaning here is “I am a software editor, and I run the company without estimates because I do blah blah” : good for you! On the other hand “Estimates are a very useful tool for me and I can’t possibly imagine why I should not use them in the context of this US DoD public procurement I’m interested in.” : good for you too! That’s OK if you use estimates successfully. I once asked if anybody had ever heard of a no-estimate-like story in the context of public tendering. The answer was “no“. That’s not a big deal either.

So why do you all fight #NoEstimates like it was some kind of a threat ? Does anyone of you think that he is going lose his job if #NoEstimates proves usable in some domain ? Would it somehow jeopardize your business ? Please ! Please tell me why this permanent, impassioned rant about #NoEstimates !

P.S. : I know, because I’ve seen it already, that some of you will accuse me to try to avoid having a discussion : not at all! On the contrary I am really, genuinely eager to understand the very Why of all this.

P.P.S. : This open letter can be read as a follow-up to #NoOthers and #NoEstimates

#NoOthers and #NoEstimates

Yesterday I promised to give some concrete examples related to what I call #NoOthers. The first one will be #NoEstimates.

What #NoEstimates should/could be

Example #1

Product Manager : “We have plenty of things to do on the product. There are many new features to add and there are also a couple of really embarrassing defects that we should address too. I need to know how long each of those things is going to take so that I can balance defects with new features in the schedule.”
Dev#1 : “Well…It ain’t easy to estimate bug fixing time before we get into it. As far as I can tell right now no bug solving ever took more than 3 days, but we can do some stats if you really need to make accurate forecasting.”
Dev#2 : “The thing is that we are not confident at all with the estimates we give you. For the smaller things we can have some interesting enough statistics based on what we already did in the past…but for user stories like foo or bar the scope is way too big.”
Product Manager : “I understand that you can’t give me accurate estimates…but I really need to know  when we are going to start working on baz. At least sales people need to know.”
Dev#2 : “We can try to split foo and bar into smaller user stories so that they can fit into the stats we have, but maybe we could just consider working on baz right now if it’s that important?”

Example #2

Customer : “I need to know how much it will cost me to have this product, and when it will be done.”
Project Manager : “Of course. But allow me to suggest that maybe your real need is not the one you think.”
Customer : “What do you mean?”
Project Manager : “Well, as far as I understand the product you want to build, you definitely need to get to the market as soon as possible.”
Customer :  “Who needs not?”
Project Manager : “Yes. So let’s first try to focus on a core set of features that will allow you to get to the market quickly. We really want to extract the features that compose the very minimum product here. Then we could improve the product by adding the other features as described in the specs…or other features if needed. Does it make sense to you? ”
Customer : “It totally makes sense…but I still don’t see how much it will cost us in the end.”
Project Manager : “It will cost you the amount of money you want to put into it! Of course for the minimum product we will provide you some kind of cost estimate after breaking the selected features into small pieces of work, but for the rest you will be able to stop when you want to.”

What #NoEstimates sometimes is / How it is perceived

Product Manager : “We have plenty of things to do on the product. There are many new features to add and there are also a couple of really embarrassing defects that we should address too. I need to know how long each of those things is going to take so that I can balance defects with new features in the schedule.”
Dev#1 : (thinking) He wants estimates, let’s give him estimates! Maybe he wants some random numbers to fill in a lottery ticket after all “No more than two days for each of these bugs IMO. foo is pretty big : I think of 7 or 8 days of work. bar looks easier so I think it won’t take long.”
Dev#2 : “Not sure about bar : nobody has touched this part of the product  for a while. I don’t think we can estimate that upfront… Hmm… What is the real purpose of this story again?”
Product Manager(thinking) Here we go again! NoEstimate bullshit! She doesn’t want to commit herself with an estimate and will argue about the purpose of every single piece of user story “Come on! You guys are incredible…”

No Others

I must admit those (almost) fictional pieces of dialog are a bit cliché, but they outline a key difference between what #NoEstimates is and how it is often perceived :

  • #NoEstimates is a hashtag that gathers people who want to try and find an alternative to using estimates as a tool. It really is a #NoOthers concept in the sense that we need to understand everybody’s needs to find the best suited tool / way of working together (and we think that estimates might not be that tool).
  • #NoEstimates is perceived as a rebellious community of developers – others – who do not want, or who simply can’t, understand what business people – us – need.
  • #NoEstimates can be used as a banner to wave in front of product/project/whatever managers – others – who do not, or simply can’t,  understand what dev people – us – need.


More will come on this subject…

Indian Planning Poker

When I first heard of estimating work items – let’s call them stories – with Story Points I was like “WOW!! That’s amazing!! No more question about how long it will take! Just estimating the relative effort, it really is a good idea!

Then I discovered Planning Poker, and again was amazed by how it can solve Asshole Driven Development issues (me being the asshole most of the time). I immediately decided to apply it with the team I was in charge of. We did ONE session, and everybody agreed that we were wasting our time. Yet we learnt a couple of things then:

  • We could easily treat small stories, the ones worth 1 or 2 points
  • We could not easily decide about big stories, and almost always decided to break them into smaller stories

All around the Web you’ll see that people recommend not to use the bigger cards of your planning poker deck, and to only keep the 1/2, 1, 2, 3 ones or so.

So we decided to give a try to T-shirt-size estimates, which was basically like keeping only 3 cards in our deck : S, M and L. We did ONE session, and everybody agreed that we were wasting out time. Yet we learnt a couple of things then:

  • We could easily treat small stories, the S-sized ones
  • We could not easily decide about big stories, and almost always decided to break them into smaller stories

Now here is the thing : we had a product to build and we wanted to now how long it would take to build some of the pieces of it (we are not discussing why here). We realized that we could not give any (accurate) estimate to answer that very question unless the pieces were small enough.

So we decided to always work on small-enough pieces of work. Obvious.

Now if for some reason you believe that you need estimates, what you can try with your team, during your next Sprint Planning Meeting, is a session of Indian Planning Poker. You actually only need one card in your Planning Poker hand: the thumbs-up card. Stick the thumbs-up card on your forehead if the story is small enough, or as small as usual, and not if not…and tell me about the results.

Post-Agile : Software Development As A Service

Maybe a new way of working for post-agile organisations

I wrote most of this article long ago but decided to keep it as a draft until recently. I actually thought that was more of an utopia than of a real, possible thing…but this changed after I watched Neil Killick’s talk on #NoEstimates.

I’ve been practicing software development in a Kanban team for several years now, around a single product. A first observation I want to make here is that current “Agile” way works fine with long-term projects, at least if :

  • you build a stable team
  • you slice the work into small SMALL pieces of work
  • you try to keep the work items of the same size, asking simple questions like “Is this work item as small as usual?”
  • you limit work in progress at every level of your process
  • you get rid of “expert” effort estimates and use historical data, statistics and probabilities instead (possible because you built a stable system thanks to the first 4 points)

When I speak to people working in web agencies or other kinds of software development shops, they often tell me it’s not going to work with small projects, when teams must work on several projects at a time, for several customers. They also tell me about contracting problems : how to be Agile – and what are the benefits of it – when dealing with fixed-scope kind of contracts?

That’s why I’d like to describe my hopes for a post-agile world, hopefully solving the issues above, by describing the kind of practice I’d like to see emerge in the years to come. I call it Software Development As A Service. It goes like this:

  • The team implements some kind of Agile/Lean principles so as to get a stable process, like what I succinctly described above.
  • We consider the team as a whole, a system converting customer money into customer business value at a (statistically) predictable rate.
  • The customer and the shop agree on some sort of Service Level Agreement based on lead time distribution for the given team. Transparency is compulsory here.
  • The contract becomes a fixed-cost contract

So I guess that post-agile really is about customers becoming agile too, and embracing the fact that software development is partly made of uncertainty.

If you have any thought on that, feel free to leave a message here or on twitter.

How good are your estimates?

An Agile iteration often goes like this, whatever the framework you are familiar with:

  • the product owner prioritizes the backlog of work items (features, epic, user stories…)
  • the team gives estimates for the top of the backlog, using story points, ideal time, actual time…
  • the team and the product owner agree on what will be done
  • the team actually does the magic
  • the team shows what has been done, and we compare with what was expected

Among any other thing, we often compare the estimated velocity, the number of story points the team thought they would tackle during the current iteration, with the actual velocity, the number of story points the team actually managed to sweep away.

By doing so we try to learn two things:

  • how fast the team goes
  • how accurate its estimates are

Pretty logical indeed : we compare expectations with what actually happened… but… WAIT A SECOND! What are the facts I am talking about? ESTIMATES? I am trying to calculate the speed of the team relying on the very estimates which I am trying to know the accuracy, and this accuracy cannot be computed otherwise than by comparing with the actual speed of the team!

BAM!!! Your head just blew up! You are a uroboros!

Now the good part, because I know that some of you still have their head rather intact. I hear you say “We don’t need to know how accurate the estimates are, we just need to know that they are always the same, based on the same scale“…and you are absolutely right. If the team always estimates work items the same way, we can easily monitor its velocity.

Now say that our team velocity is 20 story points per sprint. The backlog is full of user stories estimated at 1 or 2 story points, but one of the stories is worth 19 points. What are we going to do with it? We are going to break it into smaller stories : there is too much uncertainty, too much risk with such a big story, even if the team could theoretically handle it. Ideally we would break it into 1-point or 2-point stories, because that’s the kind of story the team is used to working with.

If we go a little further, we will realize that what we really need in order to calculate the team velocity is that every story is almost always of the same size, whatever the size, even if our intuition tells us that the smaller the stories are, the better our calculations will be.

So we stop estimating user stories with story points – or whatever – and ask the team a simple question : is this story small enough? or better is this a standard story?

A the end of each iteration we just count the number of stories done and do our math…welcome to the #NoEstimates world!

How long will we fail?

I was talking with a new member of my team about a new project’s first feature. The feature is kind of a prototype for the application, a full-stack slice of the application meant to get quick a feedback on some initial design choices. When my colleague asked me:

How long will it last?

I immediately answered:

I don’t know : how long do you think we will have to go back on our choices before we eventually get to a satisfying design? When will we be satisfied of our best bad idea?

I can’t remember the last time I have seen a developer satisfied of its first draft, or an architecture being satisfying right from the start.

The work of a developer is rather similar to the work of a writer. I recently heard French writer Bernard Werber saying that, before he can send a new book to its publisher, he must rewrite it entirely several times. He was saying that he rewrites the book without using previous versions : he remembers about interesting parts and can easily get rid of less interesting ones.

Developers follow the same approach : the first thing is to find an answer to a specific problem, which is telling a story in a way. When the problem is solved, which might not be done with the first try, developers deal with the style : is the story a little bit too long? is it easily readable? are all these characters really necessary? should we split this paragraph? etc. This is called refactoring.

So if we ask Bernard Werber to tell us how long it will last to write his next book, he will certainly answer that he cannot answer. At best he could try a pragmatic approach : “For 8 of my 10 last books I had to rewrite them at least 15 times but never more than 18 times. Moreover writing a book once never takes more than X months. We could then estimate that there is 80 % chance that I finish my next book between FOO and BAR.” Who would blame him?

Nevertheless nowadays people keep asking estimates to knowledge workers – developers. It might be story points, ideal days, or even month/man or real days. The developer must hazard himself into the dark art of crystal ball divination : he must first analyse the feature, estimate the development time of what he just imagined, predict how long it will take to get to a satisfying result – which may mean finding a better idea and implement it, predict interruptions, waiting times, bugs, perform a risk analysis, etc. It would be easier to roll a pair of dice.

I think this is the main difference between Lean and Agile Software Development : pragmatism. Making random estimates is pure waste of time, and taking decisions based on those estimates (alone) is a major risk for the project. That’s why leanists and kanbanists prefer statistical approaches and modelisations : taking decisions based on facts. Thus I should have answered something like:

Before you get in the team, the cycle time of 85% of the features was less than 8 days, and less that 12 days for 95% of them. In my experience, I can tell you that the first feature of a project is always longer than any other. Now that you are in the team, considering the fact that we must teach you how we work, we can say for sure that it’ll be even longer than usual. Nevertheless, it is impossible – I mean statistically – that it takes more than 14 days.

This post is an adaptation of http://matthiasjouan.fr/combien-de-fois-penses-tu-te-tromper/