The Communication Loop: Why Keeping Project Managers Informed is Key to Project Success

In the fast-paced world of project delivery, especially within the intricate web of software development and IT, effective communication isn't just a nicety; it's the lifeblood of success. Recently, a seemingly minor oversight on my part served as a potent reminder of this fundamental truth, highlighting how easily crucial stakeholders can be left out of the loop and the potential ramifications of such an omission. It all started with an email from another Program Manager (PgM). While her official title might have been slightly more junior than mine, we both fulfilled the same vital role within our respective teams – and in the trenches of project execution, it's the role and responsibilities that truly matter, not the hierarchical label.

Her team was responsible for delivering certain modules that our team consumed for a larger project. We had a history of successful collaboration, and the coordination between our teams had generally been smooth. However, with a new request on the table, one of our senior developers initiated a discussion directly with a senior developer from her team. This technical dialogue continued for some time between these two experts, focusing on the nitty-gritty details. Eventually, our developer looped me into the email chain. I reviewed the progress, added my comments regarding schedules, dependencies, and broader project alignment, and proceeded with the discussion. My critical mistake? I didn't take the elementary, yet crucial, step of ensuring the Program Manager from the other team was also included in this evolving conversation.

It was about a week later that she discovered she was out of the loop on discussions concerning features, potential delivery timelines, and work that her team would ultimately be tasked with executing. Understandably, she sent me an email (and I'm sure had a similar conversation with her developer) politely but firmly inquiring why she hadn't been included in these critical discussions about a delivery her team was accountable for. I had no "great answer" for this oversight, other than to acknowledge the mistake and affirm that she absolutely should have been part of the conversation from a much earlier stage.

This incident, though resolved amicably, underscores a tricky yet persistent point in project collaboration: at what stage, and to what extent, should various stakeholders, particularly Program or Project Managers (PMs), be involved in ongoing discussions?

The Shifting Sands of Involvement: Team Dynamics and Established Norms

The dynamics of when a PgM or PM steps into detailed discussions can vary significantly from one team or organization to another. There's no single "right" moment that universally applies.

• Developer-Led with Later PM Engagement: In some highly experienced or autonomous teams, developers might carry technical discussions quite far, hashing out feasibility, initial approaches, and even preliminary estimates amongst themselves. The PgM might only be brought in when concrete scheduling commitments are needed, resource conflicts arise, or formal agreements need to be documented. This often works well when the scope is well-understood by the developers and the project has a history of smooth execution.

• Early and Continuous PM Involvement: In other groups, or for projects with greater complexity, ambiguity, or cross-functional dependencies, the PgM or PM might need to be involved from the very outset of any significant discussion. They might facilitate initial requirement clarifications, ensure alignment with broader program goals from day one, and proactively identify potential roadblocks.

It’s crucial to understand that the point at which a PgM/PM typically enters detailed discussions is not necessarily a reflection of a team's "maturity" or "value system." More often, it's simply a reflection of how the working dynamics and communication protocols of that particular group or interacting groups have become established over time. Sometimes these established norms work efficiently; other times, as my recent experience showed, they can lead to unintended communication gaps.

Why the Program/Project Manager's Involvement is Non-Negotiable (At Some Point)

Regardless of a team's specific dynamics, there is no denying the fact that the Program Manager or Project Manager does need to be involved at a certain stage. Their perspective and responsibilities extend beyond the purely technical, encompassing a range of factors that developers, however skilled, may not have full visibility into or authority over.

Here are just a few compelling reasons why their inclusion is critical:

1. Strategic Alignment and Prioritization:
   A PgM often has a broader view of the overall program or portfolio of projects. They understand the strategic objectives and can ensure that new requests or proposed solutions align with these higher-level goals. At an extreme level, as you rightly pointed out, the team may have been directed by senior management to focus on entirely different critical work, making them unable to cater to a new request, no matter how technically sound. Only the PgM might have this overarching visibility.

2. Resource Management and Conflict Resolution:
   This is a primary responsibility of any PgM/PM.

   • Scheduling Conflicts: A developer on one team might agree to a timeline with a developer on another, unaware that their own team's PgM has already committed those resources to a different, higher-priority task.

   • Resource Conflicts: Is the required expertise available? Are team members already over-allocated? Are there dependencies on shared resources (e.g., testing environments, specialized equipment)? The PgM is typically the one tracking these allocations and is in the best position to identify and resolve such conflicts, often through coordination with other PgMs or managers.

3. Budgetary Oversight:
   Many technical discussions can lead to solutions with varying cost implications (e.g., using a new licensed tool, requiring additional cloud services). The PgM is usually responsible for managing the project budget and needs to be aware of any decisions that could impact it.

4. Dependency Management:
   Software projects rarely exist in a vacuum. There are often dependencies on other teams, third-party vendors, or infrastructure changes. The PgM tracks these external dependencies and ensures they are managed to avoid bottlenecks.

5. Risk Management:
   Early discussions might reveal potential technical risks, scope uncertainties, or external dependencies. A PgM is trained to identify, assess, and plan mitigation strategies for such risks. Keeping them informed allows for proactive risk management.

6. Stakeholder Communication (Broader Audience):
   While developers might communicate effectively with their technical counterparts, the PgM is often responsible for communicating progress, issues, and decisions to a wider range of stakeholders, including non-technical business users, senior management, or even clients. They need to be party to the core discussions to fulfill this role accurately.

7. Scope Management:
   As technical discussions evolve, there's always a risk of "scope creep" – where well-intentioned additions or changes gradually expand the project beyond its original objectives. The PgM plays a crucial role in managing scope, ensuring that changes are evaluated, approved, and their impact on schedule and resources is understood.

8. Tracking Agreements and Action Items:
   As highlighted, once discussions reach a certain stage, especially if they involve multiple people or teams, there's a clear need for regular interactions and for somebody to meticulously track the agreements made and the action items arising from these meetings or discussions. This formal tracking is a classic PgM/PM responsibility, ensuring accountability and progress. Without it, valuable decisions can be lost, and momentum can stall.

The "When" and "How": Best Practices for Inclusive Communication

So, how do we avoid the "missed CC" scenario and ensure the right people are in the loop at the right time?

• Err on the Side of Inclusion (Initially): It is almost always better to include the relevant Program/Project Manager (from all involved teams) in initial discussions or as soon as a request starts to solidify beyond a very preliminary technical query. As suggested, "it is best if the person gets included and they then can figure out their level of involvement at different stages of the discussion." A good PgM will appreciate being informed and can choose to monitor passively, delegate follow-up on certain threads, or step in more actively as needed. They can always opt-out of threads that become too granular for their immediate attention, but they cannot opt-in if they are unaware.

• Establish Clear Communication Protocols: For recurring inter-team collaborations, it's beneficial to have agreed-upon communication protocols. This might include:

  • Always CC'ing respective PgMs/PMs on initial requests or significant updates.

  • Defining clear points of contact for different types of queries.

  • Establishing regular inter-team sync-up meetings led or attended by the PgMs.

• Developer Responsibility: Encourage developers to proactively include their PgM/PM when discussions start to involve timelines, resource commitments, scope changes, or potential impacts on other projects. It’s not about micromanagement, but about shared awareness.

• Use Centralized Communication Tools: Utilizing project management software (like Jira, Asana, Trello) or shared communication channels (like Slack, Microsoft Teams dedicated channels) can help keep discussions visible to a wider relevant audience, reducing the chances of someone being inadvertently excluded from an email thread.

• The "No Surprises" Rule: A good guiding principle for any team member is to ensure their PgM/PM is never surprised by a major development, commitment, or roadblock. This fosters trust and allows the PgM to manage expectations effectively with other stakeholders.

• Regular Check-ins, Even for Technical Threads: Even if a technical discussion is ongoing primarily between developers, a brief summary update to the PgMs at key junctures can be invaluable.

My Learning: The Value of the Elementary Step

My oversight in not including my counterpart PgM was a simple lapse, an "elementary step" missed in the flow of a busy project. Yet, it highlighted a critical truth: the project's health depends on these connections. Her being out of the loop could have led to misaligned expectations for her team, potential scheduling conflicts that would only surface later, or her team being blindsided by commitments made without their managerial oversight. The potential "boo-boo" mentioned, and the subsequent "uncomfortable words with the boss," are very real consequences that can arise from such communication failures, eroding trust and efficiency.

Conclusion: Weaving a Stronger Web of Collaboration

In the complex tapestry of software development and project management, ensuring that key stakeholders – particularly Program and Project Managers – are kept consistently in the communication loop is not just good manners; it's a fundamental prerequisite for success. While the exact timing and depth of their involvement may vary based on team dynamics and project specifics, the principle of proactive inclusion should always be favored.

The Program Manager acts as a vital hub, connecting technical execution with strategic goals, resource realities, and stakeholder expectations. By ensuring they are informed, we empower them to navigate conflicts, manage risks, and steer the project effectively. My recent experience served as a valuable, if slightly humbling, reminder that even the most seasoned professionals can benefit from revisiting these elementary principles of communication. It's through these conscious acts of inclusion that we build stronger teams, foster more transparent collaborations, and ultimately, deliver better outcomes for everyone involved.

Further References & Learning:

Books on Project Management, Communication, and Team Collaboration (Available on Amazon and other booksellers):

"A Guide to the Project Management Body of Knowledge (PMBOK® Guide)" by Project Management Institute (Buy book - Affiliate link): The standard reference, with extensive sections on stakeholder management and communication planning.

"The Five Dysfunctions of a Team: A Leadership Fable" by Patrick Lencioni (Buy book - Affiliate link): Highlights the importance of trust and communication in team effectiveness.

"Making Things Happen: Mastering Project Management" by Scott Berkun (Buy book - Affiliate link): A practical and insightful guide to project management, emphasizing communication.

"Agile Project Management with Scrum" by Ken Schwaber (Buy book - Affiliate link): Details communication and roles within the Scrum framework.

"Peopleware: Productive Projects and Teams" by Tom DeMarco and Timothy Lister (Buy book - Affiliate link): Focuses on the human elements of software development, including team dynamics and communication.

YouTube Videos Explaining Project Communication and Stakeholder Management (too many to show here, just search for these topics below):

1. Search "Project Management Communication Plan": Many PMP training channels and project management experts cover this topic.

2. Search "Stakeholder Management in Projects": Understanding who to keep in the loop and why.

3. Search "Effective Communication for Project Managers": Tips and techniques.

4. Search "Agile Communication Practices" or "Scrum Daily Standup Purpose": For insights into communication within Agile teams.

5. Search "Avoiding Common Project Management Mistakes": Communication gaps are often high on these lists.

6. Channels like:

   • Project Management Institute (PMI) Channel: Official talks and resources.

   • Adriana Girdler - Project Management & Leadership Coach: Practical tips for project managers.

   • Praizion (YouTube channel by a PMP trainer): Detailed explanations of PMBOK concepts.

   • Business and leadership channels that discuss effective communication and teamwork.

Emotional stability - Somebody's got to remain in control during a heated discussion

This was a painful episode when seen in highlight, and something that has stayed with me the rest of my career and even intruded into my personal life. I did not do something outrageous, but the concept of making your way down a path where there is no easy way back has remained with me ever since, and everytime I get into a situation where it could become problematic, I recall the incident to see that I am not boxing myself into a corner.
The exact incident could vary, but the scenario is the same. You are Project Manager / Program Manager of a team with colleagues who have different roles, and their emphasis at different parts of the schedule is different. At a particular point in the schedule, even though both Development, Usability and Testing are supposed to be on the same wavelength, their focus and push could be different, and that is very natural. In this particular case, the situation happened at the time of the schedule when we were supposed to stop all new feature work, from that point on, all the focus would be on resolving defects in the features already implemented.
This is a critical moment for the testing team, since they essentially consider this the time when the entire product comes together, with all features working to some degree or the other (one is really considering a development process that is not ideal scrum). The integration testing happens more critically from this point onwards, and it can take a lot of time from this point in the schedule to thrash through most of the defects and make the product stable (of course, you cannot find all the defects in the product). The testing team is expected to not welcome any addition of new features from this point onwards.
This was a critical time. Some of the members of the development team had come in mid-cycle, so there was already some instability in the team, and it did take them some time to understand the product code and understand the team dynamics and work together as a team. At this time, the Product Management came in with a critical new feature (that had been introduced by the competition) which was expected to take another 2 weeks to develop, with the remaining testing time being around 1.5 months. Now, this was not an easy situation. The testing team was well justified in terms of not agreeing to take this feature, since in the end, it was their responsibility to ensure that the product was stable and had the least number of defects possible. The product manager was quite serious in terms of the need for this feature, and was pushing for it. The development team was ready to implement it.
The first meeting to discuss this was a disaster, with these stated positions being discussed, and getting heated. For me, unfortunately, being the Program Manager, it was my responsibility to ensure that the discussion remained in reasonable limits of discussion, without getting heated, and nobody getting into an inflexible position. However, in this case, at some point, the discussion went into a thread of policy and schedules, and it turned out that I started taking a more inflexible position, whereby such a change would not be possible. The discussion terminated soon after, and it got escalated, and during the midst of a discussion with my manager, I realized my mistake (while I was being chewed out). In every discussion, typically the managers need to ensure that discussions need to remain on a civil level, discussions can get heated, but nobody should reach a point where they get into a position from there was no roll-back, and certainly not the Project Manager / Program Manager. 

Program Manager - Ensuring that risks are consolidated and controlled

One of the most critical areas of a software development project is about tracking the status of the project, and ensuring that the various risks of the project are controlled. No matter whether somebody says that their work is important, but these are the most critical items of the project. A definition of risks is difficult, but for our purposes, we would take a risk as something that could cause a problem in the project. What are items that could be risks for the project and would need to be controlled:
- Features taking more time than estimated (either because estimation was not correct or because there were problems during implementation).
- There are problems with the defects cycle in the project. This can be such as more defects being generated, defect ageing being a problem, more defects being rejected after fixed, and other issue in the defect cycle that can cause problems in the project execution.
- The team faces resourcing problems - these could be because of attrition, or the adequate number of people not being there in the project, or tensions between team members or other such reasons related to resourcing.
- Components being used in the software application can cause problems because of delivery or quality issues. So a component that is being used in the project is getting delayed which has a dependency problem in the project schedule or there are quality problems in the component that are unexpected.
- There could be a change in the feature requirement during the cycle. Now, such a change is not expected, but it can happen if a competing product comes out with some features that have been welcomed or some surveys come out with a view that the feature mix is not correct. In such cases, it is not wise business wise to continue with business as-is, and so there would be changes needed which will impact the project.
These are some of the key project risks that you would enumerate at the start of the project and then track through the project. But of course, these are only some of the risks that can come up in the course of a project. The beauty (or the horror of a software project) is that any new risk can come up anytime, and the only thing you can do is to figure out why you had not projected the risk at the start of a project, and how to handle it now.
Take an example of a risk that we had not anticipated during the course of the project. We were working on some new features for our project, and the Program Manager (I don't like to use the first person while speaking about responsibilities) had listed down a set of risks based on his experience (and also after discussion with some other senior members of the team) with the objective of tracking these risks and mitigating or handling them as they emerge. However, suddenly a shocker came.
We got a query from our legal contact about some user data collecting code that we were using in one area of our project. We had a component that we were using for data collection, and so it seemed fine since the component had been verified by the legal team in terms of privacy practices. However, our team had gone a bit ahead and used the component to collect some data which was going beyond the privacy criterion. This has gone by for the past 2 versions without any problems, but in a standard review we were doing for some new work, one of the legal team members had a query about what we had done earlier, and that lead to some serious trouble.
We had to redo the work that we had done 2 cycles back, the developer who had lead that particular project had left for another team, and we were already a bit behind in the schedule. These are the kind of ongoing risks that a Program (or Project) Manager need to consolidate and track, ensuring that the required people are aware of these risks, that mitigation strategies are in place and whatever work is needed to be done by the team or by external folks are all either in progress or are just waiting for the necessary confirmations. Without these, a software project would totally go haywire.

Risk planning - Accounting for when estimates are prepared by one person and task done by another

Let me admit it straight out, this is a pretty difficult topic to write about. In all my years of experience as a manager, trying to have a simple equation or factor for working out what happens when somebody prepares an estimate and somebody else has to do the actual development / coding for that work was not possible. There was no one size fits all for this kind of situation. In the previous post on this topic (Using a confidence level for estimates for later refinement), I put some initial thoughts on this subject. The idea was that estimates are prepared at the beginning of a cycle and can be different from the actual effort put in when the work happens on that features.
It could be argued about why estimates are needed to be prepared at the beginning of the cycle, but there can be many reasons for that. One of the biggest reasons was about wanting to have a good idea about the number of features that would be possible to be done in the given cycle. This is necessary for the team, and this is very important for the stakeholders and sponsors of the team. In a number of cases, the plan for the release will not be approved until there is an assurance that a Minimum Viable Product has not been planned. Given that the release of a product can have profound implications on the financial status of an organization, it can be very important to do planning about the number of features that can be fit into the release.
Doing this estimation also allows the team to do the required resource planning, and even though the number of resources may not change too much between releases, if there is a need to do a big bang release, then the team would want to know the number of extra resources that are required for this release. So, let us work with the assumption that the team needs to do the initial estimation for the features that are planned for the release.
Now, the biggest problem that occurs is that when the work for a release is being estimated, the people doing the estimation are the more senior developers in the team. Typically, the estimation exercise can only last for around 5-10% of the total time of the release, and it is really not possible to do the logical task of breaking down the features into detail deep enough that the estimate would be very accurate. So, a lesser number of people are drafted in to do this kind of work, and an equal assumption is that the estimation is primarily done by the person using their previous experience to determine the scope of work for the details of the feature and using this for the future.
But when it comes to doing the actual development work for the feature, you cannot have these senior people doing all the work. The work is shared among the team members and this is where discrepancies come in. You can have the senior person being very skilled in doing such work, but the person who is actually doing this work is not so skilled and you end up with more effort required for doing this work. So, whenever the work allocation is being done, there is a need to map the estimate with the person who did the estimate, and the person who is actually going to be doing the work. A skilled manager who knows both these people would be able to do this to a large extent and be pretty accurate in this. At the same time, the project manager should continue to track and compare the effort discrepancy mentioned by the engineering manager with the actual effort discrepancy.

Risk planning - Using a confidence level along with estimates so that these are refined later in the schedule

The normal cycle we would follow was for a 6 month period of software development. Every 6 months we would release the next version of our software, and towards that end, we had a list of features ready for the Product Manager to consider for prioritization and decide which features would make it in the next version of the software, and which would be taken up in future versions of the software. Once such a list was prepared, the next step was to get the Product Manager to spend time with the designer and break down the feature set into a slightly more detailed set, something like Use Cases. However, the level of detail that we could do in the time period that we had was of a level higher than Use Cases (the actual Use Cases would be generated only when work on the features was about to start).
Once this level of detail was generated, the next step was to get the senior engineering leads talking to the Product Manager and the designers to get some idea about the feature, look at some workflows and implementation, and then, start looking at how to estimate these. There are many methods of estimation, but in most cases we used the method called heuristics, which is a fancy word that we took to mean that these people knew how to do feature development, they had been doing it for quite some time, and as a result, they would be able to use their experience to determine the typical effort required for doing the feature.
Next, all the effort for the list of features was tabulated, and then assigned to the different members of the team while doing balancing, ensuring that everybody got a mix of interesting and boring work (wherever possible if there was exciting work, since that would help in terms of morale). There was some rationalization of the effort reported to take into account that some of the team members were more capable while others were not so capable. Finally the list of features would be generated to be presented to the stakeholders of the team and the organization.
However, once the team would start actually doing work on these features, then the actual effort would come into play. It was quite possible that the initial effort that was listed was the final effort once the team started implementation, but there was also a high chance that the effort would change once the team actually started implementation. There could be design issues that were not expected before actual implementation started, or there could be other setbacks that happened. It could be that the person doing the estimate had not done a correct estimate and this was clear when the team actually started the estimation.
This has an impact on risk planning. Part of the continuous effort to monitor the risk involved in the project is to determine the actual state of the project and also to determine whether the features that were expected to be done in the initial planning are on schedule or not. However, it should be part of the risk matrix to try and determine the level of inaccuracy present in these estimates (even though it can be pretty difficult) and to estimate the impact this could have on the feature schedule. It is critical that the Project / Program manager has been tracking the estimate accuracy of the features and is not majorly surprised if a feature is running late because of estimation issues.