The Source for Java Technology Collaboration
User: Password:



Vikram Goyal

Vikram Goyal's Blog

Managing estimation failures

Posted by gvix on April 06, 2006 at 09:54 PM | Comments (9)

In early January of this year, my wife and I decided to build a new home on a block of land that we had purchased last year. We looked around for a fair bit, and finally found a builder (Newstart Homes) who had a plan that suited our budget and our block.

So we decided to sign on the dotted line, paying the hefty deposit of $3000, on the condition that the final costs for site works be told to us before we proceeded further. If the site works came to be of a prohibitive cost, we would have pulled the plug on the project and waited a bit longer before we had enough money to go on.

You see, the block had a curious problem. It sloped for 2.75m (9 feet or 3 yards roughly) from the front to the back in a diagonal way. This required special ways to place the house, exact details of which, I will spare you.

The builder agreed to this condition and proceeded to provide an estimate for the site works, which would be accepted as final, as it would be done by their site surveyors and professional estimators.

So in early February, we received the final site works cost of $23200. An expensive figure, but we were preparing ourselves for it.

To cut a long story short, we then proceeded to customize the house. You know, widen the cupboards a little, paint this room this awful pink, select the tiles and so forth. Except, to be told 2 months later, that the site works done in February was incorrect, performed by an incompetent staff, and unfortunately, the actual cost IS going to be prohibitively expensive.

Now, mistakes happen. That's life, even if it spoils three months of designing and dreaming up your home. What happened afterwards, however, is less than optimal.

The builder decided to get nasty. Ignored phone calls and emails. Blamed us for our 'tight budget' (Yes, that's very professional, blame the victim). And asked us to cancel the project so that he won't have to refund the full deposit, when the mistake as admitted by their estimation manager, was because of their estimation staff.

So, where am I going with this personal story and why am I telling it to everybody unconcerned with the building industry?

There is a lesson here in managing failures of estimations that go beyond one industry and apply very specifically to the software industry.

This week, I had to go to a client's place. Perturbed by the lack of smoothness in a software/hardware rollover, I felt the heat as the client replayed to me a promised estimate provided by my manager and I several weeks earlier. The client complained that the initial estimate had proved wrong and that they were suffering because of it and were clearly unhappy.

I froze on the spot when I heard what she had to say. The words were eerily familiar. Ignoring the specifics, what she said, was exactly what I had said to the builder. There was a clear failure in providing estimates in both cases. I was now the builder and my client was me (ok ok metaphorically). I struggled with the implications.

I thought to myself: "Why am I any different to the builder? I failed to provide a service as a result of incorrect estimation, same as that &#$* builder. Is the client now thinking the same $#%^ thoughts about me?"

Clearly, a case of practice what you preach was in order.

The difference, as you may guess, lay in the way the estimation failure was managed. Instead of blaming the client, I apologized for the delay, provided a reasonable guarantee of future services and delegated tasks to ensure that the problems were rectified as a matter of high priority.

Of course, the core problem remained. What about the flawed estimates? How could I ensure that the estimates didn't fail us again? Further and more importantly, how could I ensure that failure of estimates didn't leave the client more unhappy than is to be expected from a failed commitment? In other words, how do you manage programming estimation failures?

As programmers we are notoriously and perhaps naively lampooned for providing generalized estimations ('If the software guys say it will take 4 man weeks, it will actually take 8'; or 'oh this is simple, it will only take a day!'; or 'you want it when?').

Yes, not all of us are like this. But we all do fail in our estimates one time or the other. The problem is not in the fact that we provide an incorrect estimate, but if we don't manage the fall out better.

So to repeat the question, how do you manage such failures?

(BTW: If by chance you live in Australia, and by chance you also happen to live in the state of Queensland, and further, due to another fortuitous circumstance you are also looking to build a house, well, first, Hello and Good Luck! and second, avoid Newstart homes like the bubonic plague. We still haven't received our deposit back.)


Bookmark blog post: del.icio.us del.icio.us Digg Digg DZone DZone Furl Furl Reddit Reddit
Comments
Comments are listed in date ascending order (oldest first) | Post Comment

  • Not to be glib, but the best way to handle a failure is to avoid them altogether. A "failure" itself seems like, by definition, a "point in time" when a particular situation is given a name. Avoiding that point is the goal.

    I've seen practically identical outcomes, where we were in fact just short of 100% "success", and one was labelled a "failure" and one was not. In one case, we "managed expectations" (and responded to them), and in the other, we did not (we simply did the "work", and got it done). So, if you can avoid "surprises", the impact (or, recognition) of failure will be minimized. Note that "failure" often can not be hidden; that's not what I'm talking about; rather, expose as early as possible any possible problem points, and if they can't be fixed, negotiate around them. Also, if you can identify how the client defines failure (is it cost, timeline, or quality? "choose two", etc), you can negotiate away from the potential, unavoidable "failure" by changing the rules of the game before the points are tallied. Oh, and as I'm sure you noticed, having those rules in writing might come in handy (but hopefully that won't be necessary, since once someone whips out the rule book (all scribbled in with post-it notes throughout) all future matches are probably off.)

    Posted by: michael_n on April 09, 2006 at 05:02 AM

  • Upon re-read of my previous post, I was not clear:
    • The success: In one case, we "managed expectations" - and responded to them (this, upon realizing that we were not going to succeed)
    • The failure: in the other, we did not - we simply did the "work", and got it done (albeit not quite to the customer's expectations, as we belatedly discovered)).

    Posted by: michael_n on April 09, 2006 at 05:08 AM

  • From you story it sounds like they never intended to do the work. You are being far to nice. Just sue them. It tends to focus their minds a little.

    Posted by: c_armstrong on April 09, 2006 at 08:14 AM

  • Well, my problem is usually different. Managers come and ask me "how long..." when I say X, they answer"No, no, that's too much, we need it to be done in 3/4 of that" and then they go and tell the user that it will be done in 3/4 X.
    After that, you are not even allocated the resources you were supposed to have, you are given another tasks in between that have "higher priority" and you tell your manager that you are surely going to miss the deadline so he better start talking to the user, the answer is "no problem, we go on because you might have exagerated when you calculated it".
    Of course the deadline is not met and then the meetings come when they ask "how could we miss the deadline? Where did we fail making the calculations?"
    So yes, sometimes it's us developers who make mistakes doing the estimations, but many many times the problem is that the things you take into account when doing the calculations have nothing to do with reality. And many others because what you estimate is not what is told to the user.
    Oh well. Such is life ;)

    Posted by: greeneyed on April 09, 2006 at 10:35 AM

  • greeneyed, I hope you now add 33% when speaking to that manager ;-) I used to have the same problem, but some managers would round up to the nearest month, some would round down, and some would do 75% as you said... So depending on which manager asked, the estimate would differ accordingly... I always found overestimating by some, and finishing early (so you get time to fix style/layout issues) was always the easiest route in the end...

    Posted by: bloid on April 10, 2006 at 01:00 AM



Only logged in users may post comments. Login Here.


Powered by
Movable Type 3.01D
 Feed java.net RSS Feeds