GANTT in agile environment

I am suggesting to look at the use of GANTT charts in context of an agile environment from quite an untraditional angle. A modified, fully-automated, dynamic, self-correcting version of GANTT chart can be very helpful in planning and monitoring your development iterations. As a matter of fact I personally prefer it over an iteration burndown chart because it gives me alot more visibility into the project details.

I ran into this article the other day Why Gannt Charts Are Useless For Agile Projects and then followed to the next one The demise of the Gantt Chart in Agile Software Project and then simply could not resist to post my opinion on this topic.

Those two articles are based one main assumption:

One of the most important things a Gantt chart is supposed to show is the task dependencies in a project plan

Well, that have been the case for the waterfall projects and Microsoft Project tool. I would agree with the point of “the demise” if I choose to use the assumption for my agile projects. But in the context of “agile” I see a quite different use, implementation, and application of GANTTs. Talking about MS Project and manual GANTTs creation in application to software development is like taking your audience to the stone age and saying that a rock is not an efficient instrument to build a hybrid car in 2007. I think most of software teams stopped using MS Project a long time ago.

Anyway, I am not trying to argue with the articles. Once again, given that assumption, I would agree with them. I just suggest you to look at GANTT charts one more time from a different perspective. In “agile” context, and actually in context of just one iteration.

But how much effort are you investing in creating a detailed, two-month Gannt chart?

Imagine ZERO!

When you have a granular, ever-changing list of software requirements (or features or enhancements or whatever) and the team prioritizes and commits to just a few of those each iteration AND the team then organizes their own way of delivering those requirements in the space of a few weeks or less, it is really, really hard to make a Gantt Chart.

Planning

So at the beginning of an iteration when you’re looking at a prioritized (by business value, or risk, or whatever) list of features or enhancements and your team has given all effort estimates per each task, and you know that you have one month (SCRUM) for the iteration GANTT chart can help you decide how many tasks you can handle and if there is a good resource allocation strategy:

• Imagine you do not know your velocity yet.
• Or even if you think you do, imagine your resources are quite specialized and you can not assume their balanced distribution, hence this iteration velocity may be not like the previous ones at all.
• Or you want to control some resource allocation (I know many agile teams say they do not do that, but in the end of the day resources are assigned) and see its impact on predicted iteration end date
• Or you actually ran into a few dependencies you’d like to account for. Lets not disregard these completely.
• Or your software is such that in the middle of an iteration you need to freeze code development and switch into extensive systems testing and “back-and -forth” between R&D and QA. So may be you would like to model such a two-phase iteration pattern with QA’s effort estimations taken into account too?

So the benefit of GANTTs during a planning session is visualization of your prioritized plan with attached estimates to it and exploration of possibilities in terms of number of tasks to commit to, accounting for unbalanced resource assignment, and specific development+testing patterns. The trick here is really for a tool to make GANTT chart generation automatic. We use a tool where we change priorities of the tasks, enter estimates (and dependencies if desired), do resource assignment if desired and then click just one button to get GANTT chart which shows if we can meet our iteration deadline like that. Change one priority, click <GANTT>, change one resource assignment, click <GANTT>, and so on … explore the opportunities before you finalize your plan … Sure, if you had to do it all in MS Project manually that would be a big head ache. I would not want to do this either. But this tool is a release planner/tracker linked into your request/bug tracker and so you hardly have to input anything manually.

People say GANTT is bad because it is hard (using MS project) to create. But the point is, if it is created automatically to reflect your plan for an agile iteration it is quite useful. Even the effort estimates are entered collaboratively by individual developers (not by you, SCRUM master or PM). All you do is refine priorities, massage resource allocation and click button <GANTT> to see a quite realistic scenario for your iteration. I do not see how this is not useful. When the cost of generation a GANTT chart becomes ZERO suddenly you may start seeing benefits of using it.

Tracking

When you’re in the middle of your iteration, things change alot and often do not go as planned. A static GANTT chart (that was once created during your planning session) becomes obsolete and eventually useless, I agree. But again, we’re in “agile” age so why are we still thinking in terms of such static models? I suggest a dynamic GANTT chart that reflect the current situation of your iteration and in real-time adjusts predicted future portion of the iteration.

Yes, tasks get re-assigned, they change states in your request-tracker (some allow entering %completion), some tasks you decommit. A PM tool linked with your request-tracker that knows all these changes can automatically generate an adjusted GANTT chart that shows the current status of your iteration. The nice thing is that it still uses planned order and your estimates to chart the future portion for the unfinished tasks. So you can see how you’re doing against your deadline. May be it is time to stop development and switch to intensive testing in order to have something functional in time.

Well, if your Agile project goes like the ones I’ve seen, the team members will display the irritating behavior of constantly moving around to different tasks as seems most effective to them within the iteration – regardless of what you’ve written down.

Are you saying that in your projects the priorities of tasks are disregarded at the iteration level? Maybe it is fine for some teams but I would prefer for my team to start with the most important tasks first and stick to the iteration plan to minimize the risks. Otherwise my business value/risk based prioritization was sort of useless. There is no way you can track if the tasks are implemented in the desired order using burndown charts. Dynamic GANTTs will clearly show you what is happening.

Even if you are not disciplined enough to follow your planned order the dynamic GANTT is still better than a burndown chart. You can see which developer touched/started which task right away, and how much progress he has made. All this is done by a click of a button without you entering any status data manually.

GANTT and Agile

My point is quite simple. MS Project and manual chart is painful and you would not want to use it for your iterations – the cost is higher than the value. Agree!

But there is a next-generation of tools out there that automated GANTT generation process and made it very simple and useful for iteration planning and iteration tracking. One could call them dynamic GANTTs, or real-time, or automatically adjusted GANTTs, or synchronized GANTTs.

The main purpose of these GANTTs is not to track dependencies in a waterfall project but to help you more accurately estimate, explore, and track your iterations. So how is that “useless”?