The 'size' of the project is normally different at the start and at the end of the project. There is an effective way to define and control the project 'size' by defining and controlling the "Iteration Depth". "Iteration Depth" is the number of iterations to be executed for the creation of each deliverable in the project.
"ITERATION DEPTH" EXPLAINED
If we look at the 'Deliverables Layer' (my way of looking at the Deliverables of a project), then each deliverable will go through it's own life-cycle until it's completed. Completed would mean, reviewed, tested, accepted and signed-off.
The diagram below shows this concept.
Deliverables such as documents or reports will go through a standard revisioning process where each revision will include activities such as (an example):
Iteration 0: (concept from Scrum) - equivalent to an 'Inception' phase of creating a deliverable
* Writing content
* Create revision
* Distribute to stakeholders
Iteration 1:
* Review (internal and external)
* Provide feedback
* Update deliverable
* Create revision
* Distribute to stakeholders
Iteration 2+: continue same process as above
I think projects can adopt the same approach to all deliverables and improve the delivery quality and stakeholder satisfaction. Agile / Scrum software development projects use the same concept as a delivery framework.
Take the 'Release Plan' and the 'Releases' from Scrum. Each Release is in effect a deliverable and each Release has a set of iterations (if we have monthly releases, we could expect 1-4 iterations, depending on the size of the team, complexity of technology etc).
This concept works best for deliverables that invite continuous modifications such as wireframes, screen flows, user story creation, designs, usability testing etc. These deliverables easily create a 'never ending' process whereby the client always wants to change something. This is especially critical on 'Fixed-Price' projects where the effort invested by the project team to work on a single iteration is absorbed by the project team. In this instance, it's very easy to blow a budget!
CASE STUDY
I saw this concept in action especially when a project is run to a tight timeframe and deadline. On one project I was involved in, we were required to provide a design for a company within 4 days. Now after scratching our heads and staring at each other, we agreed that in order to pull this off we will need the client to commit to the following:
* Agree ahead of time to a defined number of iterations (3 in our case)
* Make decisions and 'sign-off' at the end of each iteration
* Have a single point of contact who is responsible for making the 'final' decision
The client agreed to it and stuck to the schedule. This approach enabled us to deliver to client requirements and at the same time control the scope, time and evidently the budget for this small piece of work.
BENEFITS OF "ITERATION DEPTH"
By controlling the number of iterations we can:
* Estimate effort more accurately (by allocating resources and time to Iteration 0 and subsequent iterations including activities such as meetings, reviewing, travel etc)
* Engage the client more professionally and effectively. The client will know their responsibility and commitment (it's not going to be an uncertain open-ended process until the client is happy). This will cause the client to think twice or put the extra mile for each iteration
This concept sits well with the agile software development approach
* Control project timeline. By controlling the effort for each iteration, we can more accurately define and control the overall timeline. If there are any delays from a client's perspective, these delays could be raised as project issues and dealt with straight away
* Control project budget. By providing better estimates, we in fact control the spend of the project
* Control project scope. By ensuring the number of iterations are kept, the number of times feedback will be collected is defined and controlled
* Project momentum is gained. By following this concept, the wider team (both internal and external) will be focused on progress and will ensure all hands on deck for each iteration
WHAT THE CLIENT WANTS
I must point out that at the end of the day, the 'process' for executing the project will be up to the client and some clients may want an 'open-ended' "Iteration Depth" and at the same time allowing the project to use T&M (Time and Material) as the basis for charging for each iteration.
This is of course an extreme example and normally doesn't provide the client the value they require, but it is a scenario that does happen.
The "Iteration Depth" therefore provides much needed controls to be able to better promise and control scope, budget, time and quality of a project.
T :-)
0 comments:
Post a Comment