3 Key Elements of a Successful Project
By Tomer Sagi
There are 3 key elements that make a project successful:
- The “Done” factor
- Repeatable project process
- Online collaborative simple tool to support the “Done” factor and the project process
Recently while working on a new project which has the following risks:
- Timeline is tight and budget is not reflective of effort needed to accomplish the tasks
- Implementation platform is new to the team
I have taken the approach of gathering requirements using agile methods and defined appropriate User Stories. I then estimated the User Stories with the team and was able to put some effort and budget figures against each User Story. This provided me with a more realistic view of the project overall effort and budget.
I realized very quickly that in order to ensure the project will deliver to its agreed timeline and to keep spending under control we must be able to determine and measure when we start and finish a piece of functionality. The key emphasis is ‘measure’. I realized that if we can realize when we ‘finished’ something we can then evaluate the effort invested into that piece of functionality and project it on the remaining User Stories. This is in essence the premise of agile and sometimes more specifically Scrum.
So, I set on a journey to determine when something is ‘Done’. The ‘Done’ factor.
It is ‘essential to determine when a piece of work is done. Something is ‘done’ when the client ‘signs it off’. That’s simple. But the big question is, especially when I put myself as a client, what does that mean?
Well it means a few key things:
- Determine that what’s given works
- Determine that what’s given meets the ‘specification’ or ‘requirements’
- As a client, I’m happy to take it with me and go
Taking the above in the context of software development, this translates to one question:
What ‘things’ in the project can the client evaluate? and how?
So, in this particular project we have the following functions:
- Design Integration
The ‘things’ the client can evaluate are simply:
- Tested product
Wireframes and Designs are tangible deliverables that appear on the screen or a piece of paper. They can easily be reviewed and ‘signed-off’ by the client. Tested product is more complex. How does the client ‘evaluate’ and ‘sign-off’ a tested product.
This to me means that the client must be able to have the tools or techniques to be able to evaluate and sign-off. Tools meaning testing tools and techniques could include people who have the skills to evaluate the received product. Evaluation of the received product would be against tangible deliverables (requirements, specifications, designs, wireframes etc).
So now that we know how to get the ‘Done’ factor, how do we integrate it into the project process?
Using Agile methods we can create and repeat an end-to-end delivery process multiple times throughout the project. Using releases and iterations we can develop User Stories and go through the entire ‘process’ and get them ‘done’ in a timely fashion. ‘Repeatable process’ is the key to enable this continuous and effective way of delivering and signing off User Stories.
It’s essential to have a crystal clear process that could be followed time and time again by the book which will provide tangible and accurate results.
Based on the functions mentioned above, here is a sample ‘Repeatable Process’:
Requirements, test cases and designs
- Clarify requirements
- Develop test cases
- Develop wireframes
- Review with client (“Iteration Depth” concept will ensure a fixed number of iterations is performed with the client)
- Review with team (feasibility of wireframes)
- Sign-off by client
- Develop designs
- Review with client (fixed number of iterations)
- Review with team (feasibility of designs)
- Sign-off by client
- Update requirements
- Update test cases
- Sign-off requirements
- Sign-off test cases (as they could be used by the client to test the product as well)
- Development of back-end functionality
- Conversion of designs into HTML/CSS templates
- Integration of designs and code
- Unit and Integration Testing
- Close release
Functional and other testing (Staging environment)
- Deploy to a staging environment
- Communicate release to testing team
- Perform testing on staging environment
- Iterative bug fixes
- Deploy to UAT environment
- Communicate release to UAT team (client’s team)
- UAT testing (against requirements and/or test cases)
- Iterative bug fixes
- Sign-off release
The above is obviously one example and some projects will differ slightly or greatly as per the needs of that particular project.
Now we only need an online collaborative simple tool to facilitate the ‘Done’ factor and ensure the repeatable process is established and followed each iteration and release.
Simple isn’t it?
Tomer Sagi is a Senior IT Project Manager who has been managing software projects using RUP, Prince2 and Agile methodologies for the past 4 years. He has introduced companies to agile methods and practices including Scrum, Scrum-ban, Lean and TDD.
“Chaos Dimention” is a Project Management consultancy and professional services company based in Wellington, New Zealand. “tProject” is a blog by Tomer Sagi that collects and communicates practical and time-proven project management methods and practices. Check it out at http://www.chaosdimention.com/.