Developing a software product is more than just coding. It involves strategic planning, leadership skills, technical oversight, and many other qualities one must possess to lead a team of talented engineers. Seemingly small details overlooked during the first stages of software development can result in unsatisfactory results, significant amounts of rework, budget overruns, and other unpleasant surprises. To avoid them, an IT project manager (PM) must not only be aware of the tasks the development team needs to complete but also understand where specific requirements come from. Today, we’ll consider some critical stages in the software development life cycle to understand how they affect the project manager’s routine and determine what tools can become helpful.
IT Project Manager Role and Common Challenges
Project management is the application of skills and tools aimed to improve the chances of a project reaching its goals successfully. For this purpose, managers ensure that the team of people involved in product development is in sync and on track. Plus, their task is to fill the gap between the software development team and the rest of the world, including other company departments, customers, regulatory organizations, and so on. The area of responsibility of a manager in software development goes beyond monitoring the team itself and may include budgeting, scheduling, and resource allocation. These activities ensure that software products are feasible and profitable.
Challenges in project management are as diverse as software solutions that developers build. However, most probably, no specialist in the field is not affected by the following ones:
- Risk management. Identifying potential risks early and planning how to mitigate them is crucial but often challenging;
- Stakeholder engagement. Balancing the needs and expectations of various stakeholders can be complex and time-consuming;
- Tight deadlines can sometimes create a high-pressure environment within the software development team;
- Resource allocation. Ensuring that the right resources are available at the right time can be difficult;
- Communication issues. Miscommunication or lack of communication can lead to misunderstandings, errors, and delays;
- Budget management. Keeping the project within budget while meeting all requirements is a common struggle;
- Scope creep occurs when new requirements are added after the software development has already started, often leading to delays and budget overruns.
Read Also Running From Avalanche or How You Can Avoid Scope Creep
Successfully dodging all the problems listed above and those that are beyond the scope of this article is not a trivial task. It requires due skills and experience. However, if you follow a set of management techniques and apply them from the very start of the software development process, the chances that your software development team will be saved from unnecessary fuss are pretty high. Project management systems are your best helpers in this regard. They provide tools for planning, tracking progress, and managing resources, which are crucial for navigating the complexities of software development.
The Importance of the Pre-Sales Phase or When to Start Worry About Risk Management
When the client’s company decides that adopting a new software solution will help them reach their business goals, they start searching for an organization that can help them develop it. At some point, their representative contacts the sales team of a software development company, and the pre-sales stage begins. A PM may be involved at this step for the following reasons:
- Client meetings. Participating in meetings with potential clients can help understand their needs and demonstrate how the software product will meet them;
- Proposal development. PMs often help in creating detailed proposals, including timelines, resource requirements, and cost estimates;
- Technical expertise. PMs can provide technical insights and ensure the proposed solution is feasible and aligns with the client’s requirements.
We also want to emphasize that this stage of software solution development is precisely where the team needs to start risk-management activities. Potential risks may embed a problem at the start of the product development that will fire up late during the execution. The possible framework for risk management may look like this:
- Continuously apply risk identification techniques in all activities. The simplest option is to ask team members and stakeholders if they suspect any risks in upcoming activities;
- Log or identify the risks in the risk register;
- Perform risk analysis. You need to perform a qualitative risk analysis and you may do a quantitative one in some cases;
- Select the most critical risks and developer risk response plans based on your analysis;
- During the development, you need to monitor risks and implement risk response plans.
In a perfect world, the process must not stop during the whole software development life cycle, but it’s the very beginning when you need to focus on identifying risks.
Read Also Checklist of 8 Tips in Negotiating an Outsourcing Contract and How to Get Around Them Easily
Keep Your Friends Close and Your Stakeholders Closer
By a stakeholder, we mean a person or organization that may affect or be affected by a decision, activity or outcome of a software development process. This pretty diverse group may include the PM, end-users, the client, some team members, subject matter experts, and so on. Since they provide requirements for the product the team creates or, in some cases, towards the way the software development process needs to be carried out, they need to be identified.
To do so, you need a stakeholder register. Depending on the application development specifics, it’s usually the PM’s or business analyst’s duty to make one. Still, it’s not uncommon for other team members to contribute to its development and maintenance. The stakeholder register captures all the information about stakeholders. By analyzing it, the PM specialist can decide how to interact with each of them. Here’s an outline of how a stakeholder register may look like:
| Stakeholder | Role | Interest | Influence | Expectations |
| John Smith | Project Sponsor | High | High | On-time delivery, within budget |
| Jane Doe | End-User | Medium | Medium | User-friendly interface, ease of use |
| Bob Johnson | Technical Lead | High | High | Meets technical requirements, scalability |
Building a stakeholder register for a project management system is a relatively simple task. You need such features as data binding to update and synchronize stakeholder information across the app, data processing features (filtering, sorting, and grouping), and event handling to help respond to user interactions. It can be reached by combining the following Webix widgets:
- Datatable allows data to be displayed and edited in a table format. You can use it to create a stakeholder register with columns for stakeholder name, role, organization, interests, influence, etc.;
- Form can be used to create a stakeholder registration form, where users can input new stakeholder information;
- Popup displays additional information about a stakeholder, such as their contact details or notes;
- Charts can help visualize stakeholder information, such as a pie chart showing the distribution of stakeholders by role or organization.
If the software development team fails to collect all the requirements, the stakeholder may force it to include the missed one. It may lead to the need for additional budgets or put the whole product’s fate in jeopardy.
Here’s a small example. A software development company builds a custom eLearning system for a local school district. The team delivered the software product on time and within budget, but they failed to identify the state’s Department of Education as a key stakeholder. Unfortunately, it has specific regulations governing the collection and storage of student data, which the software development team was not aware of. Redesigning the data storage system to comply with the regulations is a job that requires a lot of rework and additional expenses.
Project Initiation and Project Charter
During the initiation process, the project charter is what forms the foundation for successful management in subsequent stages. It’s a simple text document that may include the following information:
- Project description;
- Business case;
- Project objectives;
- Preassigned resources;
- Stakeholders;
- Known requirements;
- Description of deliverables;
- Assumptions;
- Constraints;
- Potential risks.
You can compose one for your software product in MS Word or Google Docs or use a project management solution for IT teams your company uses. It doesn’t need to be very big. Five pages tops should be enough. It helps to form a common understanding, remove lots of miscommunications, and better control the client’s expectations. The team’s future goals need to be aligned with the project charter. Future planning must help achieve the objectives stated in the charter. Also, you need to dig deeper into the high-level information this document contains.
Collecting Requirements
It’s not necessarily the PM who makes this, but rather a business analyst or product owner. However, sometimes, the PM’s role in the team implies requirements collection. The goal is to take high-level requirements and scope from the project charter, break them into smaller pieces and start working out the details of each requirement. If needed, the team writes specifications and user stories, draws mock-ups, etc.
First, the team collects business requirements from the clients, then identifies stakeholder requirements, and after that, produces solutions and specific product or system requirements. When the software development process is up and running, new requirements may appear and must be shared with the team. Here, you have multiple options. For example, a video call with the team or stakeholders to discuss the requirements or client’s message in Slack or other communication apps with a specific feature request. A short video of the client’s screen demonstrating what works wrong and what should be corrected may clarify the whole situation.
Take the time to truly listen to and understand your client, to grasp the nuance between what they say and what they mean, and you’ll create a product that brings joy to everyone involved.
- Collect and break down high-level requirements into manageable pieces;
- Store and organize requirements in a centralized location;
- Collaborate and communicate with team members and stakeholders through video calls, messages, and attachments;
- Share requirements and updates in real-time.
Source: Project Management Application Based on the Gantt Chart
Scope Management
Now, you need to turn abstract requirements into real results your software development team can deliver, which are called project deliverables. The industry specifics and the nature of the specific software product will dictate the most common deliverables. Plus, you can rely on requirements you already collect to divide which deliverables they’ll turn into.
The client won’t necessarily have the same knowledge of how the software development process works as you do. Therefore, you need to explain what they will get as a result. The project scope statement describes all deliverables and the way they are created in simple language. It’s critical to have one because you’ll put tons of time and management effort into creating a plan and implementing those exact deliverables. Also, it helps show the client that the development team’s work results will help them reach their business objectives. Ideally, clients need to put a signature on this scope statement.
The next stop is turning deliverables into the work breakdown structure.
Decomposition Techniques
The work breakdown structure contains deliverables and smaller pieces of work called work packages. They all have identifiers to allow them to state their position in the overall picture. After you list all the major pieces of your future software product, you need to decompose them into work packages, each of which is a tangible and testable product part that fits within the reporting period. Work packages then must be decomposed into a set of tasks, ideally small enough for a single team member to complete.
To represent such a task structure in an intuitive way, you can rely on Gantt charts that can become helpful for anybody and not only for software development teams. For example, once we made an application for a client with DHTMLX Gantt charts that turned out to be pretty convenient:
Source: Project Management Application Based on the Gantt Chart
Task Assignment
After you convert requirements into actionable tasks, you can use a familiar management tool to assign them to specific team members. When creating tasks, define three essential elements:
- Hours. Estimated time required to complete the task;
- Deadline. Task completion date;
- Responsible Person. Assigned team member.
Read Also Web Development Team Structure. Key Specialists and Their Roles
Include these details in the task description, along with relevant screenshots or explanations. The IT project management system you rely on must enable the following functionalities:
- Track process status;
- Assign tasks to software development team members;
- Set deadlines;
- Estimate task duration;
- Track time spent on each task;
- Monitor progress within tasks.
Moreover, access to staff information within the PM software enables visibility of team members’ workload, skill sets, and availability. It can help assign tasks, ensuring that the right person is working on the right task and at the right time. Also, it can help identify potential bottlenecks and allocate resources more effectively.
Source: Project Management Application Based on the Gantt Chart
Project Execution
Your plan outlines the work, but it doesn’t have all the detailed instructions for technical problems, solving conflicts or motivating team members to act. That’s why part of the PM’s work is to encourage and facilitate interactions between team members, stakeholders, and subject matter experts. You need to motivate them to search for solutions to technical problems and implement them according to your plan. Then, you need to resolve conflicts, remove impediments, track progress, interviews, performance reviews, one-on-one meetings, training, discussions, and so on.
Read Also When “Softer” Means “Stronger”. The Importance of Soft Skills for Software Development Team Members
All these activities transform into some sort of communication, like emails, calls, or documentation. To avoid having a bottleneck, empower your software development team members to solve problems independently by creating rules for self-organization. Here are some rules to get you started:
- One record per user story. Create a single record for each feature in your management system (e.g., Jira, Trello);
- Attach relevant information. Include all relevant documents, comments, and discussions related to the user story in its record;
- Simple workflow. Establish a clear order of tasks for each user story, such as:
- Mock-up
- Mock-up approval
- Back-end development
- Front-end development
- Integration
- Automated unit testing
- Functional testing
- Customer acceptance testing (UAT)
- Deployment
- Kanban board. Create a board with columns for each step in the workflow and cards for each user story;
- Move stories right. Move user stories from left to right as tasks are completed;
- Focus on your column. Team members focus on user stories in their designated column and complete tasks accordingly;
- Move to the next column. After completing a task, move the user story to the next column;
- In case of emergency, return to the previous column. If information is missing, move the user story back to the previous column;
- Ask the right person. Team members should ask the person responsible for the previous task for clarification if needed;
- Inform the Leader (Optional). Team members should only involve the leader when necessary and instead ask the person responsible for the previous task for answers.
Read Also Software Development Life Cycle (SDLC). All About Kanban Model
By following these rules, your software development team will be empowered to work independently, and you’ll avoid extra bottlenecks.
To implement the rules for self-organization mentioned above in your own custom-made PM solution, you can use the DHTMLX Kanban Board, which can help create a board with columns for each step in the workflow and cards for each user story. It would allow team members to visualize the workflow and move user stories from one column to the next as tasks are completed.
Project Baseline
The project baseline is the final approved version of the scope, schedule and budget. Baselines are critical for any management approach because they help track progress towards the initial goal. The idea is that you have a plotted path, and you continuously track your progress along this path. If you deviate from it, you adjust course to get back to this line by acting as the situation requires by changing your management techniques, hiring more developers, and so on.
Read Also Making Your Team Bigger the Most Efficient Way. How IT Staff Augmentation Works
The plan provides predicted values. While development progresses, you collect the actual values and find out that nothing ever goes as planned. The proper management technique implies tracking all aspects of the IT project, such as quality, communication, stakeholder engagement, team motivation, etc. If you see deviation, you start applying productivity techniques, motivation, leadership tricks and maybe even a bit of micromanagement to get back to the initial plan.
Demonstration and Analysis of Work Results
From time to time, the team needs to showcase what they’ve been working on. For this purpose, the development team can set up a demo instance for every product. Also, every two weeks or so, you can have a demo meeting with the client. The meaning of this is to show them the progress and get their feedback on what’s working, what’s not, and what needs to be changed.
During these demo meetings, you can talk with the client via Zoom or Google Meet, for example. Then, you can show them the app demonstration on the screen. You then go over everything with the client and collect their feedback.
Generating reports is an essential part of progress analysis as it helps provide a clear summary of what the team has achieved and highlights areas that require improvement. By generating reports, the software development team can:
- Track progress. Reports help both developers and clients understand what’s been accomplished and what needs to be done;
- Identify areas of improvement. Reports can help better understand what exactly doesn’t work and as planned;
- Set and clarify goals and objectives. Reporting allows the development team to build a basis to set more realistic goals by comparing the actual task completion with the initial plan;
- Enhance transparency. Reports promote transparency by providing a clear picture of the project’s status and accountability by tracking progress and outcomes.
A reporting tool built with Webix Report Manager can significantly help the development team by automating report generation, providing a centralized report storage, streamlining report distribution to stakeholders, enhancing report analysis, and improving collaboration.
Source: Project Management Application Based on the Gantt Chart
Conclusions
Team management requires navigating various challenges, from tight deadlines and resource allocation to communication gaps and scope creep. Luckily, structured management techniques and powerful software tools can help overcome these challenges. Relying on the proper management strategies and technologies allows for project success and stakeholder satisfaction. Contact us if you’re looking for a custom web app to reach your business goals better or need to strengthen your project management team with custom-made software.