Subscribe by Email

Friday, November 2, 2018

Project Manager - Keeping the morale of people up

The job of a Project Manager in a software project is a complex one. Technically, the Project Manager is supposed to lead the project in the best possible manner, and try his / her best to understand the issues faced in the project, raise them to the best possible manner in order to resolve it and keep as much as on schedule as possible.
In reality, the Project Manager is the person who is the last resort person. He or she is the one who needs to understand issues which have rose in terms of complexity and drive /delegate the process of resolving the problem. This may also include resolving issues related to morale within the team.
Now, morale can be a team problem, or it can be a problem with specific members of the team. I remember a large project I was involved with, critical to the future of our team. Rumors started floating in that the project was being cancelled since the client was dis-satisfied and would drop the project. However, senior management was not conveying any sort of decision and team members were getting very low in morale, with the subconsious feeling about why work so hard for customization for a client where the project would be dropped.
It is in such a situation that the Project Manager and the team leads have to play a critical role. One part is to try to find out from senior management about whether the project is indeed being cancelled, or was there a chance. Once the status is know as well as knowledge about what parts can be shared with the team, it is important to share status with the team on an ongoing basis. Getting information from rumors can be incredibly bad for morale, it is better to discuss within the team, take questions and ensure that people are in a better way, and getting into such a discussion helps (and this is applicable not just in a case where the project may be cancelled, but there may be other issues that could cause morale problems).
More tricky is the case where one or more of the team members are having morale issues, or some other emotional issues. This is tricky to resolve when this kind of problem is causing productivity issues (and in a lot of morale and emotional issues, there will be impacts on productivity). It is the responsibility of the Project Manager and the team leads to identify cases where a team member might be having some kind of morale issues. This kind of becomes critical when there is an associated impact on productivity. Discussion needs to happen with the team member, although the discussion can become very limited if the issue is more of a personal or family nature, something that the manager needs to handle with some delicacy. What cannot be left unsaid, whether delicately or clearly, is that the impact on productivity needs to be set right - the Project Manager would be remiss in his or her duty if this is not handled well. 

Monday, June 26, 2017

Generating an agenda for a meeting - Getting inputs from the team

When you go into a meeting with another team or group, one of the most important inputs when going into the meeting is to ensure that you have an agenda item ready for the meeting, and equally important, that the critical items have all been covered in this agenda. How to generate an agenda for the meeting that is comprehensive and ready in time is something that different teams have used different methods (depending on their internal processes). Some of these methods are:
- Setup a small team to decide on the agenda. This could be a section of the senior leads or the ones from the directly affected areas, Such a process can be a pretty effective process if the agenda items are to be driven up from within a closed team. The way it would go would be for one of the leaders to be given charge of this process, and being given dates and deadlines for this stuff. They can in turn have smaller meetings with individual team members as required to figure out individual points. The agenda items being created would need to be reviewed on a regular basis and modified as appropriate. Over a period of time, as the team leads get more experienced at this process, they will get more effective and be able to drum up these agenda items much more quickly.
- In cases where the team is more geographically dispersed (or even in cases where the people required to work through the agenda items are more likely to be spending their time on email), a simple email thread involving the required folks can slowly start to build agenda items. Depending on the critical nature of the meeting, this can be more formal or informal, there is hard to define a proper level of formality for such an email discussion. It does need one of the team members (team leads / program manager / project manager) to drive this process and ensure that it remains on focus and continues to generate the required agenda items.
- Another 'process' that I have seen a few project managers follow is for them to send a quick note to team members about a meeting with the other team, and asking team members to shoot out agenda items along with a deadline for such submissions. These typically help in generating a list, but it would take some more discussion and refinement before these can be put in the form of an agenda item for the meeting.
- Then there are the cases where both the teams have agenda items for the meeting. It could be that some of the agenda items are not new, but are a continuation or progress from previous agenda items, and the discussion on these is a continuing affair. In which case, for generating the agenda items (including a quick one line on the current status), discussions between team members from both the teams need to happen at whatever level of seniority is required for the discussions.

There would be other methods for generating agenda items for important meetings, and there would be tools that also help in the same; the above list is based on my experience as well as discussions with other team managers.
The opposite, going for a meeting with no clearly defined agenda items or something that has not had this kind of preparation, would expose you to a meeting that may not be as efficient as you would want the meeting to be, or in the worst case, be a total disaster. Not a good place to be. Use the above steps / processes, or use your own, but be sure that agenda items for a meeting are the default, unless the meeting really does not require an agenda item driven approach.

Wednesday, June 22, 2016

Artwork: Refreshing the artwork for the product

What is the artwork for a software product ? The artwork for a software product is all the visual imagery that is used in the product. This could be the application icon that you see in the top left corner, this could be the image that you see when the product is being loaded, this could be the icons on the various dialogs and screens of the application. If you ask an engineer on the product development team, he could not care less about the artwork (some are concerned, but most would be concerned about the impact of delivery of the artwork on the overall schedule and the screens on which they are currently working).
Why is the artwork important ? Well, you could also buy some simple stock images and icons (or get them designed from innumerable free or low cost options available on the internet), but the problem is, the artwork is part of the overall branding of the product and has a significant role to play overall. For those who monitor the overall branding of products, when companies make a change in their branding or in the icons, it is a big effort.
From time to time, there is a need to refresh the artwork used in the product, it makes the application feel fresh. It is not so easy to perceive, but users get a bit jaded when they see the same artwork, the same icons in the product across different versions. When the artwork is refreshed, it gives regular users of the application the feeling that they are seeing something new, even though reviews may not give too much importance to the change in artwork. Further, when there are changes to the look and feel of the operating system on which the application works, there is a need to make changes to ensure that there is a sync between the operating system and the application. For example, it could be that the new operating system has icons that have a certain amount of transparency, and applications that do not have the same kind of look and feel stand out (and that too in a negative way, not positively).
However, refreshing all the artwork, or even part of the artwork is not an easy task. It cannot be done without an expert - you have visual designers who talk to the product management, who talk to the product team and senior management, who talk to the customers (we actually had meetings with a group of customers to get their feedback on different sets of proposals for new artwork to see which seems to work, and which does not).
The artwork design and creation process has a separate schedule and is normally done outside the base product team and their schedule, so there are some complications that need to be overcome. The project / program manager needs to ensure that the schedule for this delivery has to be done before the dialogs overall delivery is complete, including some time for evaluation and review, and rework. And then the dialogs / screen would need to be shown to outside reviewers to get their overall feedback and impression, and corresponding changes would need to be done.
There is further impact. Since the artwork is changing, all the screenshots of the application in the Help documentation (in the base language and in the other languages in which the application is available) need to be changed, and this can be an intense effort that takes time and a lot of work (including testing that the change has happened in all the languages).

Tuesday, June 21, 2016

Supporting previous versions of the software (Part 6)

The previous post (Supporting previous versions of the software (Part 5)) talked about a team trying to make a decision about whether to drop support for a previous version of the software or not. If you are a user who is impacted by dropping support for the version of the software you are using, you would think that the team has taken such a decision without thinking about users. However, such decisions are not taken without a detailed discussion, and maybe after thinking about this decision at multiple levels before the final decision on dropping support is taken. However, it can be the exact reverse decision that could happen. With some serious defects having risen, the team has proposed that these cannot be fixed easily and also because these problems are for an older version; however, when a decision is finally taken, the decision is the exact opposite. The support for the previous version is not removed, and infact, the team is told that with these severe defects, there needs to be a fix provided to users.
With this decision, it can provide quite a challenge for the team to provide the dot release / patch for the release, but not impossible and hence they have to plan for it. There are a number of parameters that need to be considered, evaluated and a solution found for all of these. Some of these are (this is not an exhaustive list, if you see more parameters, please let me know through comments):
- Whether to release a dot or patch: What is the difference ? The terminology could vary, but typically consider 2 different kinds of releases ? One is where you have a simple small executable that just updates the few files required for the fix, while the other is a complete release that essentially replaces the application that they have on their machine. The reasons for deciding which method to use is also complex; it depends on the number of files to be updated, as well as the actual mechanics of issues such as upgrades, dependencies, etc. This decision is typically an engineering decision.
- Number of resources to be used for the release: In most cases, teams do not get additional resources for handling such updates unless they are doing this on a regular basis. So, some amount of work estimation needs to be done to determine the number of resources needed, as well as the schedule on which they will be needed.
- Support from external teams: For any product release, there is support needed from additional teams such as testing, installer and release, documentation, etc. Even if there is a small update to be provided, there is a need to ensure that these external teams are in place and committed to the effort, This can be a challenge sometimes.
- The timeframe for this effort needs to be decided: This can be a challenge sometimes. Typically a dot or a patch needs to be released pretty quickly, and there is a need to optimize to ensure that the existing engineering work for the current version is not impacted. This schedule can be a challenge, since the priority will remain the work for the existing release, and yet there needs to be an update.
- Update problems / engineering issues: Whenever an update / patch / dot release for a previous release needs to be released, it needs to be checked with the application installed on the user's machine. This includes ensuring that the application continues to work fine with the update, including the standard checks. This means that the team needs to install previous versions of the application and even replicate the operating system version that some of the customers might be having.
- Informing the users through support teams, forums and so on. There needs to be a campaign to inform users about the impending update release and ensure that feedback needs to be taken quickly when the update is released.

Tuesday, May 31, 2016

Supporting previous versions of the software (Part 5)

In previous posts in this series (Supporting previous versions of the software (Part 4)), we have talked about how an organization makes the decision to remove support for a (much older) previous version of the software. Removing support means that customers are encouraged to move to a higher version, defect fixes are not provided and the support team will not take any more calls on that version. This can get tricky, and sometimes the decision is not all that clear as to whether the support would be withdrawn.
For removing support for a previous version of the software, the groups that typically advocate removing this support are the development and testing teams; the number of previous versions of the software that remain supported in the market, the more effort they need to put in. For example, just as an example, there are a lot of compatibility issues that need to be developed and tested, and these increase as the number of previous versions are supported. Another example would be the support team, since they have to keep a track of issues, defects, notes, and other items for all the previously supported versions. However, when you look at product management and marketing, they have a lot more contact with customers, and they are able to better figure out whether it is possible to drop support or not.
I am going to try to layout some reasons where the team took the call regarding whether to drop support and decided that they cannot drop support as of now. Here are some of the reasons (and this cannot be a comprehensive list, more based on my experience in the industry).
- Too many users complaining about support being withdrawn: This happens when the team informs people through support forums and the helpdesk that they are planning to drop support. If there is significant push back (and discussions with some those protesting reveals that they are really going to be impacted), then the organization may decide to not drop support as of now.
- Previous deals commit support for an extended period of time: This happens typically in the case of OEM's or when there is a large deal. As part of the deal, support was required for 5 years after the launch of a version, and this grew tricky in the years to come. But we were bound by this condition, and the only learning was to be more careful of the implications of providing support for extended periods of time.
- The Product Management / Marketing looks at data, looks at support discussions, user forums and decides that the level of discussion is still fairly high enough that the support needs to remain for some more time.
- Data from metrics reveals that the understanding of the team was incorrect regarding the number of people still using the software and the data reveals more people that are using the software. In this case, it could still mean drop of support along with an offer for those people using the older software to get some concessions when they are upgrading to the latest version.

Read the next version of this series (Supporting previous versions of the software (Part 6))

Sunday, May 22, 2016

Supporting previous versions of the software (Part 4)

This is a series of posts on the subject of when an organization decides to drop the support for a previous version of a software. Say, you are working on version 8 of a software and version 4 was released 4 years back, and the management team is trying to make a decision on retaining support for the software version. In a previous post (Supporting previous versions of the software (Part 3)), we had talked about a situation where there is no choice but to drop support, because of a dependency issue. The previous version used a software component that is not working properly and there is no way to fix this; in many such cases, the organization has to take action. It cannot pretend that the previous version is working fine except for a few glitches, and instead would need to declare that the version is no longer supported. When it says that a version is no longer supported, it actually means that there will be no support, no updates, no bug fixes and it is recommended that users upgrade to a newer version of the software.
What happens in the case where the organization has no data metrics about the number of users who are using the previous version of the software. Well, it does get kind of tricky, but these situations have happened in the past. The emphasis on being able to trap user interaction and mine this data for doing all sorts of analysis (including determining usage habits) is something that is of relatively recent vintage, not being emphasized even 4-5 years back. Now, every product tries to capture user interactions, which workflows use more often, and so on; but consider the case when this data was not being tracked and now the organization wants to drop support for a previous version of the software for which they do not have this kind of data.
Just because they do not have this data does not mean that the organization will continue to support previous versions for a long time. There is an increasing heavy cost associated with supporting long back previously released versions of software and at some point, the organization will decide to drop support. If there is no user data, the organization could check with support teams and with user support forums about the amount of queries that come in for these previous versions of the software, and if it seems that there are a large number of users that are active for those versions, then it makes sense to not drop support for some more time. On the other hand, if it turns out that there is hardly any interaction related to that specific version, then it might make sense to take the decision to drop support. Of course, there is some amount of subjectivity involved in this, since forums might not be a totally accurate mechanism to determine whether there are a lot of people using that version, but it is a hard choice. You have no other mechanism to determine the usage levels and you have to use some kind of proxy to help you make that decision.
One way is to make announcement about dropping support in another few months, and then see the reaction. If there are a large number of people who voice complaints and so on, then it might make sense to interact with some of them and determine whether they are really discomfited if support is dropped, how often do they really need some kind of support and so on. Even in such cases, after due discussions and interactions, it may still be possible to drop support (even if there some amount of opposition, as long as it is containable).

Monday, April 4, 2016

Supporting previous versions of the software (Part 3)

This is a line of posts that talk about the reason why software companies may drop support for a previous version of software that they have released. For example, Microsoft has released many previous version of the Operating Systems (out of which a number of them are no longer supported), many previous versions of its Internet Explore Browser (again, many previous versions of the browsers are no longer supported), Adobe has released many previous versions of popular software such as Photoshop or Acrobat (and periodically drops support of previous versions of the software), and so on. Does it mean that there are no problems when the organization drop support of these versions of the software ? No, but the number of users who are outraged by this dropping of support is low or there is an upgrade path for those users and hence it is possible for the company to do this.
In the previous post (Supporting previous version of the software - Part 2), we talked about having analytics and data information about the number and percentage of users who are using the version of software that is proposed to be dropped, and hence the organization can take an informed solution.
In this post, we will talk about a situation where the hand of the organization is forced. For those involved with designing software products, the question of component dependency is a double-edged sword. When you are making your own software (we'll consider the case of building a software product for the Windows environment), you do not build each and every functionality. There are many organizations that have built components that do specialist work much better than you would be able to do so. For example, for building a video application, it would make more sense to license the usage of a specialist video codec that does it much better than you could. With this advantage, there are some disadvantages as well. You have locked yourself to this component (and large modern software products may use tens or hundreds of such components). In most cases, even when the external component gets upgraded, the upgrade would happen in such a way that software products using such a component can still work. However, over a period of time, especially when a number of years have passed, there can be many problems that come up because of this component dependency. For example, the company that has built the component has gone out of business, or sold the business, or did something similar. This may still work, but it gets even more complicated when defects start cropping up in that component (and customers start reporting those defects). In such cases, when the version of the software is pretty old (more than a couple of versions old), the organization starts veering to the decision that it cannot fix the problem. Even if a fix of the component gets available in some way, it would just be possible to easily fix the problem, or the effort involved to fix, and test this problem would be deemed as not justified.
Consider another case where the software dependency is on some component for which support itself has been withdrawn. Consider the case where you would have integrated a previous version of the Internet Explorer browser support in your product, and Microsoft has withdrawn support for this version of the Internet Explorer. When you start running into multiple such problems, then taking a decision to drop support becomes easier.
Read the next post in this series (Part 4)

Facebook activity