Handing off a project to a client; what are the risks and challenges?
Software project management is activities aimed at ensuring that a software product is delivered according to a client’s specifications regarding time, budget and product capabilities. Some projects may recur while majority are one-off projects. Software developers pay keen attention of one-off projects because their success builds on their reputation. Once a software product has been completed, the developer hands it over to the client. This stage, however, involves several risks that may render all effort put in developing the software useless. These risks include:
- Undiscovered bugs – Some bugs might not be found during the testing process. They may become apparent while clients are using the new software and, thus, inhibit the efficiency of the software. In some situation, a small but serious bug might break the entire application. Such bugs may frustrate the client, leading to loss of future software development jobs from the client. In addition, the dissatisfied client may badmouth the software developer, leading to loss of business reputation. The solution is to test the applications thoroughly before handing off.
- Handing off too much stuff – software developers run the risk of handing off too much information and project materials that may confuse the client. The more the hand off materials, the higher the risk of confusion in the client. For instance, a website developer may hand off the source code plus the website to a non-technical client. The client may try to initiate changes to the source code on their own and cause program failures. Therefore, developers should hand off what is relevant to the needs of the client. During the project development, developers produce different designs and make multiple revisions until they obtain the final product. It is not necessary to hand off all the revised designs to the client as the client may choose the former developed design instead of the final design, creating more workload to the project team.
- Product does not work in the way the client want – Sometimes, the product is fully functional. However, the client does not like the way it works. This risk results from the failure of the project team to seek the feedback of the client during software development. In order to avoid this risk, the team should demonstrate the prototype at the end of each sprint so that the client understands how the software works. The team must also incorporate the client’s feedback at the end of each milestone agreed upon before the start of the project. Obtaining feedback ensures that the client participates in the project. Feedback also minimizes the risk of misunderstandings, errors and rework (Das, Mahapatra, Pradhan, 2013).
- Not adhering to the handing off format of the project – a developer may hand off a project in a format not stipulated by the client during the initial phase. For instance, the developer may hand off the software documentation in paper format while the client stipulated softcopy documentation. Failure to adhere to format requirement may increase the chances of rework and cause project delays. The solution is to follow the client’s specifications such as delivering software in a CD or DVD and installing a website the client's server (Nguyen, 2014).
- Not adhering to hand-off time – software or website developers face the risk of handing off a project at the wrong time. This risk can result from delivering a project when the client is not expecting it. Projects delivered too early increase the risk of rejection by the client, believing that developer put little effort in their execution. On the other hand, delays in project delivery may frustrate clients and disrupt their plans regarding the project. Hence, developers must adhere to the time constraints agreed upon before undertaking the project.
Software and website engineers should adopt formal hand-off policies in order to minimize these risks. The policies should cover issues such as documentation, format, milestone scheduling, budgetary requirements and risk management plans. The benefits of risk management plans include reduced duplication and rework, obtaining precise estimates, and identification of alternative actions when risks arise (Bannerman, 2008). Hand-off procedures differ with the type of client. For small business, developers may need to set up a server for the client and upload the final product. For big companies, developers may consult the technical person in the company on the best way to hand off. Furthermore, hand-offs involve the back and forth exchange of information between client and developer team that consumes a lot of time and money. More often, the software or website developer may need to hand off the project using some specified SVN server, or upload a file via their VPN services, or even uses a third-party software. All these require additional time that may cause hand-off delays. Therefore, earlier communication between the developer and the client is crucial to ensure a smooth handing off process.
Delivering a project and presenting to a multi-level audience
Project delivery to the client often involves activities aimed at streamlining the client’s adoption of the new software or website. Such activities include providing training, maintenance of the client’s software or website, providing necessary deliverables and improving the general appearance of the product. Training programs assist clients in using the product, creating a seamless transition from product prototype to business functionality (Das, Mahaptra, Pradhan, 2013). Training can occur over a specified period, usually from one to two weeks.
Maintenance programs are necessary to correct unforeseen bugs that may arise during the real-time execution of the website of software. They may run for about a year, after which clients pay developers specified maintenance costs for bugs or faults resulting from their mistakes. Deliverables are the outcomes expected from the project. They include software deliverables and document deliverables (Momiroski, 2002). Software deliverables are the functionalities that the product was developed to accomplish such as tools for customer subscription on a website. Documentation deliverables describe the project, from initiation to termination and the specifications involved. It guides clients on how to use the new product and correct minor problems that may not require the assistance of an expert. The challenges that may face delivery include time and budget constraints, low product quality, and difficulty of use (Shah, n.d.). However, these challenges can be minimized by adopting effective project management techniques.
In most cases, the business clients require a formal presentation from the developer regarding the new product. The audience may consist of people with varying levels of technical skill. The purpose of the presentation is to obtain feedback from other professionals regarding the effectiveness of the product. It also assists in assessing the ease of use of the product by obtaining feedback from those unskilled in the software development field. The developer and client agree on the time and place, and plan the structure of the presentation. Software or website presentations complement documentation and demos by giving a brief background and software features (Rajapaske, 2010). The presentations are short and focus only on the key attributes of the project, giving allowance for audience questions. An important thing for developers to remember while making such presentations is not to assume that the audience understands the technical terms used just because the developer understands them. Therefore, developers must simplify any technical terms or give their meanings to maintain rapport with a multi-level audience.
Presentations may assume different formats such as creating charts, using specialized presentation software, creating a scientific poster and presentations through the client’s website of the intranet (Vrije Universiteit Brussel, n.d.). Charts are beneficial in listing the features of the software and comparing it with another software present in the market or previous software that the client used. Presentation software such as Microsoft PowerPoint make it easy to summarize the contents of the presentation. They also eliminate the need to take notes on a board or chart. Most presentation softwares have formatting tools such as color schemes, slide designs and background themes that give presentations aesthetic value. The presenter only needs a projector and a white screen to magnify the presentation to the audience. Scientific posters may vary in size depending on the scope of the presentation. They are suitable for presenting diagrams rather than words and sentences.
Finally, the presentations on the client’s intranet may take the form of a series of slides containing the background and use of the product. This method makes it possible for the stakeholders of the client organization to access the information and rate its efficiency of use. The measures of a successful presentation include the degree of positive evaluation from both technical and non-technical members of the audience. Afterward, the client can accept or reject the project (Cobb, n.d.). If the client rejects the project, he or she may recommend the changes that the developer must make on the project.
References
Bannerman, Paul L. (2008).Risk and risk management in software projects: A reassessment. The Journal of Systems and Software, 81(2008), 2118–2133. Retrieved from http://www.nicta.com.au/pub?doc=800
Das, T. K., Mahapatra, D. K., & Pradhan, G. K. (2013). Towards Large Scale Software Project Development and Management. IOSR Journal of Computer Engineering (IOSR-JCE), 8(6), 20-35. Retrieved from http://www.iosrjournals.org/iosr-jce/papers/Vol8-Issue6/D0862035.pdf
Nguyen, Luan. (2014). Handing off a project to a client; what are the risks and challenges? Retrieved from http://luannguyen100w.wordpress.com/2014/11/11/blog-8-handing-off-a-project-to-a-client-what-are-the-risks-and-challenges/
Rajapaske, Damith C. (2010). Chapter 14: Project Presentation. Retrieved from http://www.comp.nus.edu.sg/~damithch/guide3e/Ch14.html
Shah, Sunil. n.d. Global Delivery Excellence: Best Practices for Improving Software Process and Tools Adoption. IBM Software Universe. Retrieved from https://www-07.ibm.com/in/events/swu08/pdf/day1/itservices/global_delivery_excellence.pdf
Vrije Universiteit Brussel. n.d. Presentation Software. Retrieved from http://www.vub.ac.be/BIBLIO/nieuwenhuysen/courses/chapters/present.pdf
