How NOT to manage large and complex projects in 2020

Today, modern solutions offer a valuable infrastructure for managing complex projects and end-to-end processes. This is achieved by providing high customizability accompanied by a low-code and modular approach to development.

In order to understand the massive benefits of this new approach and countless opportunities it provides, let us see why the old approach has consistently failed companies, what today’s expectations on new solutions are and how we can avoid the tragic consequences of managing a large-scale project with an outdated tool set.

Managing projects: Stone Age style

Before collaboration-oriented web solutions were a thing, people used desktop applications including Excel or MS Project to manage their activities and to-dos[1] . It was like the “Stone Age”, if we consider Web 2.0 “civilization”. Since there was neither a reliable Internet connection nor a suitable web-based tool, desktop applications were the way to go.

The most common backlog and reporting management tool to bring back some nostalgia is the mighty Excel. A project manager (PM) could have project items (e.g tasks, risks, resources, etc.) and plans neatly listed in an Excel file, with various columns addressing different attributes such as deadline, responsible person, involved resources, start and end date, complications, status, etc. If our PM is diligent, as she should be, she updates and logs everything regularly and uses a few Excel macros and tricks to change the color of a few cells and calculate the value of some others based on different criteria (e.g. priority or deadline). It seems quite alright, doesn’t it? Well, it depends.

If our PM wants to manage her personal activities and tasks, an Excel file or its online equivalent (e.g. Google Sheets ) may do simply fine. There is no need to overcomplicate stuff.

Having said that, we are not talking about managing and tracking personal to-dos, but those relating to projects or processes that involve more than a few people and interdependencies. What is wrong with using such a fancy macro-filled Excel file? A lot more than you may think.

Obvious problems

Notification nightmare

Managing items in Excel requires extensive manual communications both inwards and outwards.

For starters, daily communication is often needed with various team members and stakeholders to collect information in order to keep the backlog up-to-date. Also, keeping certain stakeholders or accountable roles informed requires that after certain updates, these people are duly notified. This has to happen via an e-mail client or a messaging service, something that takes some additional time and, in most cases, cannot be tracked, measured or relied upon. In addition to all this, sending status updates via a different tool is not only a manual hassle but also a risky business, since these updates often contain sensitive information. Lastly, people tend to forget to send such updates, which can result in unnecessary complications and escalations if one stakeholder with a high ego and low tolerance feels left behind and uninformed.

Sending reminders manually to the responsible members if a deadline is approaching is another example of mundane activity that costs time and is a cognitive burden. All these notifications, whether as status update, assignment alert or reminder, can easily be carried out automatically with the appropriate tool(s) and the right design.

Accessibility & verification horror

If you have ever tried to manage the items of a relatively big project “collaboratively” on Excel (sort of an oxymoron), you are aware of a few possible unfortunate scenarios.

One problem is accessibility. Those organizations that are still using Excel for such purposes often use antique file repository tools such as file servers or SharePoint to store and share their files[2] . These repositories usually happen to be in a secure network of the organization, accessible only via a VPN. This poses difficultly in accessing these files or tools outside of the organization. Some may also copy a version of these files on their local system until they gain access to the repository. More than often, by this time a new version has already been uploaded, resulting in conflicts and headaches.

Even if everybody has constant access to the repository at all times (for example by using Google Sheets or Office365), some sheets need to be constantly updated. In such cases, it is not rare that the sheet in question is either locked, or people start changing and replacing each other’s values, resulting in conflicts and confusions.

Last but certainly not least, in many occasions you notice that all of a sudden something does not add up in your Excel sheet. Either your data is lost or the value of a column that was the result of 20 nested formulas and was perfectly working until yesterday all of a sudden starts returning nonsense. And good luck finding out how and when the whole thing got messed up by whom.

Reporting hassle

When information on tasks and other items is handled in Excel or alike, generating meaningful status reports inevitably becomes a cumbersome struggle. This is caused primarily by unsystematic and decentralized communication, and the fact that for status updates various persons-in-charge should be contacted. Reports should also be generated manually by merging different data sources. One additional problem is that the information on reports is not integrated or linked with the actual source. For example, if a high-ranking manager sees that the number of risky assignments in a project has increased this month, he cannot conveniently click through the data and find out what which assignments and why.

In extreme cases, generating a report costs so much time that basically at the moment when someone receives the report it is already at least one week old. In one case, a company’s HR could not produce any reports on incurred recruiting costs more frequently than every season (yes, you read that right), since the report generation process took a few weeks to finish. With a week of requirement collection and a few days of implementation, a system was produced (in this case based on Jira), where recruiting process and cost management was done in the respective workflows. With this new approach, management could see the expenses of the current month and the predicted cost of next months in real-time. Magic? No. They simply used the right technology and designed the right framework. And it saved them hundreds of thousands of Euros per year, if we only consider the direct effects.

Hidden issues & costs

In addition to obvious problems mentioned before, there are quite a few hidden issues with managing your backlog “Stone Age Style” as well.

Data collection and validation

In every process, certain data need to be collected with regard to the defined steps along the way. In modern approaches towards project and process management, this is carried out in a systematic way, with necessary validations to ensure data quality.

For example, imagine the case of a simple migration. This hypothetical migration consists of contracting a service provider, finding an appointment for the migration, waiting for the appointment and then carrying out the migration. In Excel, you may have different columns for a deadline, migration date, service provider, etc. However, one cannot force people to enter these appointments at the right time (e.g. when they are changing the status from “finding an appointment” to “waiting for it”).

This lack of control over the flow of data has dire consequences on reporting and communication. If data collection is enforced and encouraged methodologically, all necessary information will be available to generate reports automatically.

Furthermore, a central repository for all relevant data attributes decreases the need for communication. A considerable amount of communication is about requesting or providing data and status (e.g. when is the next appointment for that particular case or what is its status), which can be skipped when data is collected and stored transparently by the corresponding person-in-charge.

This is why large organizations with an old approach to project management invest millions of dollars and fill their PMO with hundreds of staff. They would need one-third of that number if they had a modern infrastructure. And this overpopulation of PMO has another negative consequence: communication problem. This brings us to the next topic with huge hidden costs: communication.

Central communication channel

In order to push an item through a process that involves various assignees to do certain tasks in the right order, communication[3] is inevitable. Communication can happen between team members, between members of different teams or between team members and stakeholders. For example, considering our previous case of a simple migration, communication can occur in order to agree on an appointment, confirm a proposed solution, as a question or by raising an issue or concern.

In Stone Age project management, written communication is done primarily via e-mail[4 ]. Using e-mail for process- or project-related communication causes more problems than one might be aware of. Mails and mailboxes cannot be easily assessed, tracked or quantified. This inevitably brings manual labor into reporting and monitoring. E-mails are difficult to be shared properly in a future time as well. Newcomers often do not have access to the email history of their predecessors.

Project managers and team leaders are also interested in following up certain discussions or know the background of a decision or situation. Even if they are kept in the loop by being “CC-ed”, it is hard to go through and find the right conversations with regard to a certain case. This further increases the communication demand.

A central communication channel solves all these problems Thanos-style in a snap. Whether it is a case or a topic, whether relevant communication is carried out via systematic and central channels, transparency is increased significantly, resulting in less redundant communication. Slack , for example, is addressing this issue by providing systematic and topic-related channels for communication; and apps such as Halp can integrate communication with backlog management. In other modern tools, the comment section of each item or case can act as the central communication channel. In Excel or MS Project? Take an educated guess.

Permission concept

Enforcing a decent permission concept is next to impossible in primitive tools such as Excel. Sophisticated solutions offer flexible and comprehensive permission on various actions, including viewing, adding, editing, commenting, assigning, deleting, linking and so on. In older approaches and tools, only limited control can be exerted to ensure the quality and legitimacy of content. This means that either one person should be in charge of updating a massive Excel file, which is impractical for large projects and complex processes, or a group of people may have access to content. The second option results in untraceable or unauthorized edits and changes (remember, we are talking about large teams).

One can sit and mourn for hours when your formulas are all of a sudden wrong or broken or a whole column has just magically disappeared, but it will not bring back your data.

Step-wise execution

Last but the most important problem with old tools is lack of customized workflows for each underlying procedure. Bringing order to the flow of existing processes in a project is not feasible in older tools. There are often numerous conditions to be fulfilled (e.g. certain columns should be filled out) in order for an action to be carried out in the right chronological order. Developing macros and limitations on such columns takes so much time that it defeats the purpose of using a tool for managing the activities in a PMO.

This may seem a minor advantage to some. However, it has a far bigger impact on how efficiently you execute a process and how systematically you collect, evaluate and share data along the way. The “workflow-oriented” approach resolves this issue.

Online PM sites: Same donkey, different saddle

Some of the inadequacies of Excel or MS Project can be resolved by using an online version of these tools that may offer a more collaborative approach towards data management. For example, every team member can be assigned a task and update it herself. This increases accountability and traceability. Using such online solutions is certainly a decent step forward, however, in the wrong direction.

In two-dimensional project management tools, no matter whether we are talking about desktop applications or their younger online versions, “rows” represent an item such as a task, assignment or change request and “columns” serve as data attributes.

The pivotal problem of using two-dimensional solutions is that in order to add more dimensions, you basically have two options: either to add a new column which might have little to do with the actual item; or to replicate the same 2D format and then link the two “sheets”. One common practice is to create separate sheets with the same structure for different assignees, companies, cities, etc. The more sheets and columns you add and link, the more complicated your “tool” becomes. This in turn lowers the usability and visibility of your backlog and, “surprise!”, it increases the maintenance cost.

For instance, imagine you want to steer migration process of about 500 agencies in Excel. Each migration has about 5 related tasks and 10-20 30 different attributes, including key data of the agency, responsible people/roles, important dates and costs, possible risks and finally the outcome of performed actions. To manage such backlog for each agency, you need 5 rows with 30 columns, many of them redundant for certain rows. In addition, you need to create 500 different Excel files, or 500 sheets (per agency) or repeat the 5 mentioned rows 500 times to cover all agencies. Should a new step be added to your process after you have designed your magnificent Excel file, you will have to refactor everything that has happened so far for all 500 agencies (in other words: repeat the same stuff 500 times). And having done all that, you still have many of the hidden and obvious problems listed in previous sections.

The good news is that it does not have to be like that in the year 2020. As hinted before, a workflow-oriented and low-code approach is the key to solving the complications that arise from a two-dimensional data system.

Imagine if project-related items could be assigned with regard to the activity type and status, and the assignees could receive notifications and reminders accordingly, update the status and necessary data attributes of their assigned item and pass it on to the next person in a predefined chronological order. It would be even more impressive if all relevant reports were automatically generated with real-time and linked data, and all updates would be logged automatically, right? You bet. And it is possible.

In the next post , the new approach and possible solutions to create an appropriate landscape for managing a complex and/or large-scale project will be discussed.

Footnotes

[1] Backlog is basically a list of items that needs to be done or tracked. These items can be to-dos, assignments, risks, resources, leads, etc.

[2] Using a file-oriented approach towards knowledge management is a huge sign (symptom) of a backward IT landscape. Information should be dealt as “content”, not as “file”. More on this in the bonus chapter on Confluence.

[3] Please note that „communication“ is distinguished from „notification“ that was addressed in the previous section, “Notification Nightmare”. Notifications, including status updates or reminders are a one-way delivery of information. Communication is two-way and is meant to answer certain questions, address certain issues or agree on an approach or solution.

[4] Assuming that we are passed the Paleolithic and the miserable usage of paper of course.