A software development process has to keep pace with the changes upstream and downstream. This implies the changes that transpire during the lifecycle of the project. Such changes may include changing user requirements, technological changes, changes in the external system on which the new software is dependent. During the course of software development, one needs to ensure that steps to mitigate risks are undertaken. In this article, let us take a deeper look at this.
Risk mitigation by developers
1. Taking a low risk approach
Software development risks can vary a lot. For instance, risk associated with inter-system communication, incapability to manage offshore development group, compatibility between system requirements and need of the users. Consider a controlled delivery of software as it helps you to do reality check and facilitates in providing a feedback to the users during the course of the project.
2. Tackling computer crash
Computer crash often results in the loss of crucial data. Loss of data permanently is a matter of great concern both for the client and the credibility of the developer. A client needs to ensure that the developer takes multiple backup copies of the software in development and all the code & documentation files need to be saved in multiple locations.
3. Late delivery issue
A timely delivery of the software is crucial for many companies. Software incorporation plays an important part for the client from strategic point of view. A late delivery will dampen their growth plans. Stringent checkpoints need to be created by the developer to ensure that the development is progressing with respect to the delivery deadline. In case there is any delay due to unavoidable reasons, extra efforts need to be made to meet the deadline.
4. Coping with lack of experience in the development team
The development team leader needs to ensure that the team members know the languages and techniques necessary for the project. The team member with maximum experience in that particular kind of project needs to be used effectively to train other members. His ability and talent needs to be used to create benchmark for the entire team. Furthermore, each team member needs to help his fellow team member to ensure comprehensive software development.
5. Stabilize database system
Database error can arise due to poor programming and error checking. Developers who are in constant touch with the database system need to ensure that other members are informed about the errors instantly and corrective measures need to be taken to avoid such problems in the future. The database needs to be left in its original form to locate possible issues.
6. Maintain the quality of documentation
The documentation personnel need to be in regular touch with the developers. Documentation suggestions need to be taken and then a call needs to be taken about documentation changes & additions. This ensures that documentation is up-to-date. Unnecessary documents need to be removed and the developer team needs to be alert to spot any missing documentation.
7. Avoid deviation from software engineering standards
In case the deviation occurs, steps need to be taken to match the project with the standard documented procedure. The team members need to possess a thorough understanding of the software process.
8. Re-check your risk-handling capacity
During software development, a reality check is important. You need to find out the duration of the iteration. It could range from a few days to maximum of four weeks. If it still looks like three months long, then your process could still be waterfall with long feedback cycles and a high risk factor dangling over it. Each iteration cycle needs to deliver some portion of actual working software to the users. It ensures opportunity of giving a feedback before it’s too late.
9. Follow the basic norms
Try and adopt iterative risk driven approach. Senior management needs to be a part of the project since the beginning. Their commitment and involvement will keep the development in track. Apart from that, team leaders need to ensure that there is seamless communication between the team members and users. Moreover, the development team has to be highly skilled. Visual modeling techniques need to be given a priority. Having a rigorous change control system in place is equally important. Let us take up these points one by one.
a. Iterative risk driven approach
Iterative approach helps to create portions of the software over a short period so that it can be demonstrated to the users to get their feedback and suitability. This ensures risk minimization at an early stage itself as the development focus is more towards functionality.
b. Senior management commitment
Software development is a complicated task. Commitment from senior executives is extremely important to ensure that the development is heading towards the end goal. Moreover, in case of software failure during the development, the developers might feel dejected after all the hard work being put in. Senior management helps them to take corrective measures and boost the morale of the developing team.
c. Seamless communication among team members and users
The entire course of software development needs to be accompanied by communication with the users. It ensures that all aspects of functionality are being considered right from the beginning. It also helps in incorporating ideas that are generated during the development phase.
d. Highly skilled development team
The development team needs to have a high aptitude to produce productive results. Periodic training of developers is important so that they are aware of the updates in process and techniques in the software industry. You can consider hiring a project consultant who can keep a check on the quality of the developers.
e. Change control mechanism
One thing is for sure that you have to maintain a flexible approach in terms of accommodation during the software development process. Many a times, it happens that a development phase has been completed but suddenly a change is required to be made. How well you are prepared to accommodate such changes and what effect it has on the economics of the project become significant factors for a successful project.
f. Visual modeling
A diagrammatic approach towards software development brings out more clarity in complex issues. Visual modeling techniques using Unified Modeling Language (UML) needs to be favored by the team leader to carry out crystal clear communication across the team.
Risk mitigation by client
1. Advance payment in parts
The usual software industry norm is advanced payment made to the developer as the developer never puts in money from his own pocket to develop software. The risk factor is solely on the client. To avoid releasing a massive chunk of payment in one go, the client can link the advance with the progress of the project. Once the client is satisfied with the progress, he or she can replenish the advance wallet. The payment mode adopted needs to be instantaneous to avoid any hindrance to the continuity of the project. This approach secures the interests of the client as well.
2. Three-phased payment schedule
As the name suggests, the payment is scheduled in three parts. The first payment is made as an advance to begin the project with client bearing the risk. The second payment is made at an interval where both the parties share equal risk. The third and final payment is made once the project is delivered to the client. Here the developer is at a risk, if the client is not satisfied with the end product. To avoid such as scenario, many developers create a virtual testing environment for the client. Once the client approves the testing results, the final payment can be made to developer and the developer can then transfer the ownership of the software.
Risk mitigation by both the parties
1. Type of contract
If the developer and the client enter into a fixed price contract, then the scope of deliverables is limited to what is agreed. The dispute arises if there is any change requested by the client. Though the onus of the risk is on the developer here but the client ends up paying more than necessary amount.
On the other hand, if the contract is time-based, then the onus of the risk comes to the client. The developer might drag the project to bill more number of working hours. So, a mutual understanding needs to take place between the two parties by considering the pros and cons associated with both types of contracts.
Conclusion
Risk mitigation is not one man’s job. Each member of the organization is supposed to undertake risk management. The entire development team needs to consistently monitor the progress of the project to identify on-going and future risks in the system as accurately as possible. Even the members who are not directly involved with the development needs to stay alert to spot any risk in the development process.
