The project usually begins well. You prepare the specification, then you tackle the developments, and lastly there’s the testing phase before production begins. And then, all manner of bugs start to pile up and the delivery deadline is fast approaching. You start making corrections and try to get on with it quickly, but new bugs are created. On the delivery day or very shortly before, you’re forced to put back delivery to another date. The solution for avoiding this situation consists of 4 key elements: definition of the scope, planning, execution and testing.
Element 1: the scope
It defines everything which must be in the project and everything which is not part of it. It is essential that you are aware of all the tasks involved if you are to finish a project. If not, requirements will pile up and the completion date will be continuously put back.
To make this scope clearer, you need to follow two essential steps: modelling and the drafting of the specifications.
- Modelling of the web, mobile or other application is the representation of a suite of screens which simulate browsing and using the application. This will help to highlight the different options possible. This should be carried out in collaboration with the client, validator or person requesting improvements. So the client will have a clearer idea of their project and feel secure in the knowledge that they have the same understanding as the project team.
- The drafting of the specifications involves providing full details of each of these screens, as well as the different management policies.
Describing the project in detail at the outset avoids further work at the end.
Project scope planning is the 2nd key to success. The scope must firstly be divided into independent features which can be deployed into production separately. These features should be divided into two categories: “Must have” and “Nice to have”. The “must haves” are obviously of higher priority and should be executed first. By planning in this way, you can avoid the tunnel effect during a project and roll it out gradually. The client might decide to put a version into production at any time, rather than wait until the end of the project.
The planning should allow for a fast production launch
It is now time to implement the planned features in line with the models and management policies. But how should this be done? I think it’s better if the team organises itself to determine what each member of the team will do. By choosing for themselves, the team members will be more motivated to carry out their particular tasks. The time spent on each feature is also estimated by the team, keeping to reasonable deadlines. Obviously, estimates can be imposed, but that will lead to a quick and dirty approach which will increase the number of bugs during testing and affect quality. Each feature must be well defined and accompanied by the associated testing plan to make the work required clearer and ensure that certain management policies are not misinterpreted or forgotten. Each feature created must be ready to be put into production without having to wait for the project’s other features to be completed. It is a good idea to have all features accessible from a dashboard or a chart so the whole team can see how the project is progressing. If all these elements are in place, the team will maintain a good rate of progress, and feel comfortable, motivated and committed.
A committed team finishes its project quickly and appropriately.
The quality of the project
You must obviously ensure that the product delivered corresponds to the models and specifications prepared when defining the scope, and that there are no discrepancies. The better the quality of the project, the closer you are to completing it. This goal can be achieved by the developers and the quality team. At the beginning of the project, the quality team should prepare the test plan based on the specifications. This plan will have to be implemented on the completion of each feature to ensure that it is ready for deployment. This avoids having to test everything at the end and encountering bugs which disrupt the testing phase. The development team also has an important quality assurance role in the project. Firstly, by creating the features in line with the specifications and models. Then, by developing automated tests which are carried out on the completion of each feature or bug correction. These automated tests are essential because they will reduce the amount of work required during the testing phase and avoid any potential setbacks.
A good-quality project is a project which can be put into production immediately
We’ve just had a look at the key success factors around which I base all projects. There may be others (including purely technical success factors - technical architecture, the organisation of the code, code quality monitoring tools...), but the ones outlined here are the key success factors to focus on!