Level 6 Project Management #

1. Abstract#

This document will serve to provide Level 6 students with additional knowledge of project management, included in this document, will be guidelines on how to overcome and manage risks and dependencies that are likely to occur during the software development lifecycle. By this stage, you should have a good grasp of project management, especially using an Agile approach. for a reminder, feel free to access the Level 5 guidelines here.

2. Table of Contents#

3. Biggest Risks in Software Development#

Software development is often difficult to predict and plan. It is often intangible, and involves a large number of stakeholders. These factors can create a number of risks that you will need to manage on your projects. The following are 5 of the biggest risks in software development, both internal and external:

  1. Inaccurate Estimations (deadlines, budget, iteration etc)
  2. Scope Variations
  3. Stakeholder Expectations
  4. Poor Quality Code (difficult to read or review, poorly tested)
  5. Inadequate Risk Management

These are based from reference [1]. There are many more potential risks however these are likely to be some of the most common to you as Level 6 students. To be aware of further risks, check out reference [1] at the bottom of this document. Pay close attention to number 5. Most, if not all of these can be mitigated with proper risk management.

3.1. How To Manage Risks#

In order to manage the risks highlighted above, first, you’ve got to identify and plan. Then be ready to act when a risk arises, drawing upon the experience and knowledge of the entire team to minimize the impact to the project. You can manage these risks by partaking in the following tasks:

  • Identify risks and their triggers
  • Classify and prioritize all risks
  • Craft a plan that links each risk to a mitigation
  • Monitor for risk triggers during the project
  • Implement the mitigating action if any risk materializes
  • Communicate risk status throughout project

These are based from reference [2].

Communication is the best way to mitigate internal risks, such as inaccurate estimations, stakeholder expectations and scope variations. Poor code quality can also be mitigated with communication, if you identify any potential lack of experience in a particular area early, such as code commenting, then you can work on improving that area.

It is important to always be aware and monitor all aspects of the project to catch any risks early, so you can then impliment the mitigating action before the risk develops even bigger. We also expect you to be using a tool at this level, to track all of your projects. You can find information on what tools we recommend, along with some walkthrough examples here.

4. Dependencies#

You will often find on projects that many tasks can be dependent on the completion of another. This can be very frustrating if you are waiting on another developer to finish their work on another task so you can start yours. Following are a list of dependencies you may encounter on the software development lifecycle:

  • Technology Dependency: Dependencies arising from architecture, design, coding, components etc (e.g. Program A cannot function until Program B is developed)
  • Data Dependency: Dependencies related to data readiness to complete project tasks (e.g. Acceptance Tests cannot start until we get adequate data for testing)
  • Application/Service Dependency: Dependencies involved in developing, maintaining or testing your current application with reference to other related or dependent modules, applications or services
  • Build Dependency: Dependencies relating to compiling programs in the right order, often comes under Technology Dependency
  • Operational Dependency: Operational dependencies such as release dependencies, data migration dependencies, connectivity dependencies

These are based from reference [3]. Technology Dependencies will be the most common to you as L6 students.

4.1. How to Manage Dependencies#

Dependencies can often be very difficult to manage, but there are some general strategies you can follow:

  1. Prioritise your tasks and dependencies (if a number of tasks depend on another, work on that task first)
  2. Use a tool to track your project (e.g. Trello), becoming aware of dependencies early
  3. Establish policies early to avoid headache later by employing proper time management
  4. Use automation where possible to save time and reduce exposure
  5. Communicate with your team at all times

Some of these are based from reference [4]. The most important strategy is to communicate at all times, use a tool to identify dependencies early, and prioritise them appropriately.

5. References#

[1] Code Bots. What are the 10 biggest risks in software development? By Mikaela Robertson. https://codebots.com/library/way-of-working/what-are-the-10-biggest-risks-in-software-development.

[2] Cast Software. Risk Management in Software Development and Software Engineering Projects. https://www.castsoftware.com/research-labs/risk-management-in-software-development-and-software-engineering-projects.

[3] SE-Thoughtograph. How Do You Manage Dependencies in Agile Projects? http://se-thoughtograph.blogspot.com/2013/12/how-do-you-manage-dependencies-in-agile.html.

[4] White Source. Dependency Management: 3 Tips to Keep You Sane. https://www.whitesourcesoftware.com/free-developer-tools/blog/dependency-management/.