Why Does Collaboration Software Suck?

Why Does Collaboration Software Suck?

Let’s face it, the collaboration space has no shortage of options. Today’s solutions come in different flavors of SaaS, on-premises or hybrid, all promising you that a few mouse clicks will have you collaborating better. The one attribute most of them have in common is they suck. In fact, many of these solutions actually make collaboration worse. To help you navigate your options, let’s lift the hood and explore many of the common problems with today’s collaboration solutions.

Collaboration software shouldn't suck. Learn about some common problems to avoid.
  1. You Get Pieces & Parts 
  2. Too Small or Too Big, Won’t Scale 
  3. Who’s Working for Whom?
  4. Comments <> Collaboration
  5. They’re Expensive
  6. Golden Handcuffs 

You Get Pieces & Parts

Let’s face it, as a business grows so do your needs. This transition happens slowly and before you know it you look down to discover you have lots of little solutions each itching a single scratch in helping you collaborate better. Worse yet, navigating between those tools is often painful. In the best case the integration features adds even more buttons to an already complicated user interface. In the worst case you will have to manage a bunch of bookmarks to get to specific features. 

On the subject of user interfaces, today’s solutions are all over the board. Geek-centric solutions might make your IT teams happy, but could alienate your project managers, product managers and upper management. Some solutions create busy-work for team members so that management can have pretty reports.  Other solutions are too enterprise-y, trying to be everything to everyone, but making everything more complicated instead of more efficient. Their lack of focus makes the user experience painful – with too many links, buttons, and tables, all competing for your attention.

Finally, the lack of a comprehensive feature set makes portfolio management difficult, if not impossible. Some solutions focus on work (tickets, issues, tasks), some focus on the process (kanbans, CI/CD integration), and others focus on people (chat).  But what about the bigger picture?

  • How many projects do we have in flight? What’s the relative health of those projects?
  • Have we spread our valued team members too thin? 
  • How do I find quickly find what I’m looking for? How about searching all the things (projects, users, tickets, documents)?  Centralized searching isn’t something you can do without… – yep, you guessed it – buying another tool. 

Next, let’s discuss the insanity of help desk solutions. It’s common for projects to deliver solutions to customers who need access to a support team. Isn’t a ticket just a ticket? Why do vendors try to upsell a separate help desk solution? Under this model, if a customer raises an issue that requires remediation by your team you end up with two tickets: one ticket in the help desk solution and another ticket in the collaboration solution. In most cases there is no inherent association between the two.

Now let’s think about turnover. When someone leaves your organization, how easy is it to revoke their access? Even if you’ve identified the replacement for a departing team member, reflecting that change in multiple projects can be cumbersome. And, once again, if you’ve been upsold both of those processes become harder.

The final point worth considering is discoverability. This may sound ridiculous, but many solutions don’t allow you to specify who is able to discover a project in the first place. If you are doing real portfolio management then knowledge sharing is critical, and you should be able to specify who can discover projects. Similarly, you should have a way to explicitly limit discoverability to certain projects. 

Too Small or Too Big, Won’t Scale

Not all projects are created equal. Say that again: not all projects are created equal. In a world where organizations have dozens or even hundreds of projects, in various phases of development, support and retirement,  it’s important to be able to scale up or scale down features without the headache of buying more seats or finding a new solution.

Then there’s the SaaS/Cloud versus on-premises discussion. That decision should be yours and your choice shouldn’t make deployment and management any harder. There’s no shortage of on-premises solutions, yet many require painful, complex installation and upgrade processes. Given the critical role collaboration solutions play, getting them up and running (and keeping them up-to-date) needs to easy. Many of these solutions cannot be installed at all without  an internet connection for the server. This means installing a collaboration solution on your super secure network will be difficult if not impossible.

Then, once you are up and running, how do you control access to your projects? Access control varies greatly between collaboration solutions. Large projects often have large teams, with technical, management, and stakeholder members, each playing a role in successful delivery. Believe it or not, some collaboration solutions don’t allow you to define your own roles, instead, imposing a set of roles often giving users access to either too many or too few features. Roles are a key in any real collaboration solution and are often reusable, specifying the level of access users have. And even if you can specify roles on your project, if you’ve been upsold you may well be stuck having to manage access to each upsold feature separately.

This is where the tools start to run the team. What started out as only a ticketing solution soon includes a wiki, chat, help desk and next thing you know, you are looking at a bunch of tools, held together with duct tape and web hooks, none being the authoritative source of your precious project data, and all individually imposing different ways for you to get your job done. When will this nonsense stop?

Who’s Working for Whom?

That question may sound absurd but, yes, we are asking that question with a straight face. Are your tools working for you or you having to bend to their will? To illustrate, let’s start with something as basic as ticketing. Tickets are the atomic unit of work by which things get done. All your planning, distribution and tracking of work happens through tickets. In fact, most of your collaboration will be centered on the best ways to deliver the work outlined in a ticket. So why do so many systems get the most important, fundamental needs all wrong? Let’s answer that by identifying common shortcomings of many collaboration tools:

  • Duplicate Tickets – When creating a ticket should the system let you know you may be submitting a duplicate? Furthermore, shouldn’t the system give you hints that maybe the problem or goal in a ticket has been addressed already on sites like StackOverflow?
  • Batch Updates – Updating multiple tickets in batch should be easy to do. Yet many systems either don’t allow for this or make this far more difficult than it should be.
  • Quickly Adding New Tickets – In the planning phase, it is common to create multiple tickets at once all within the same milestone or sprint. Most systems require you to rekey many of the same pieces of data instead of using sane defaults.
  • Ticket Types – While the distinction about tickets is important (e.g. user story, epic, task, bug), adding flexibility shouldn’t slow the team down or make things more complicated..
  • Imposing Workflow – Workflow can help teams stay on track and handle tasks in a consistent way.  But your ticketing solution shouldn’t force a specific workflow on your team..
  • Dependencies – Dependencies between tickets is common. Solutions should make establishing blocking/non-blocking or parent-child dependencies easy and obvious.
  • Spam – Getting notifications that a ticket, sprint, epic or milestone has been changed is great, but do you really have to get a separate email for each update? Solutions should provide the option of receiving daily digests. 
  • Ticket Previews – Because the work in tickets can be a part of any milestone, release, sprint, etc you often need to know more detail than just the ticket number and summary. Yet, surprisingly, many solutions don’t give you ticket previews everywhere and every time tickets are referenced.

Comments <> Collaboration

Repeat after me: “Comments aren’t collaboration”. Don’t get me wrong, commenting on a ticket, wiki page, or document aids in collaboration but it isn’t true collaboration. That’s why we’re seeing all sorts of chat solutions rushed to market. Chat solutions are great and often serve as the central hub of any successful project. Here again, the upsell issue bites us but in the case of chat, it is exacerbated. Chat conversations give concise context and often include references to key project artifacts (tasks, support tickets, documents). For those exact reasons, chat should be a foundational and well-connected component of any real collaboration solution, not an upsell. For example, with an upsold chat solution, when you add a new team member you also need to manually give them access to the corresponding chat rooms or channels. And remember that problem about centralized search? Did a teammate answer your question inside of a ticket, wiki or in the chat channel? Shouldn’t a real collaboration solution answer that question for you? Why should you have to run the same search in different places?

They’re Expensive

A common problem with many collaboration solutions is that their base functionality has a high price tag. And despite that high initial cost, they have a limited scope, implementing only a few well thought out features. Make no mistake, this is on purpose – vendors use this approach to get you to spend more money. They accomplish this in one of two ways:

  1. The Vendor Upsell –  Do you want to add a chat solution to that fancy ticketing system you bought? They have an app for that. Oh, now you want some sort of documentation/wiki solution? Yep, get out your checkbook. The problem with vendor upsell is it often creates more problems. On top of having to negotiate a new contract for each product, you are now on the hook for keeping all your shiny, new tools integrated.  Now this integration may not be an issue if you are all in on cloud-only solutions but as soon as you bring any of those solutions in house you are stuck with keeping them connected. 
  2. Marketplace Ecosystem – Some collaboration solutions get around their lack of features by offering a marketplace where third parties can offer you solutions that integrate with your vendor of choice. This has all the same problems as the vendor upsell but now you are adding another vendor to the equation which, on top of the pricing issue, it means the integrations are going to be more fragile and any breaks in compatibility puts you at the mercy of both vendors.

Golden Handcuffs

With collaboration solutions playing such a key role in Getting Things Done, the more you use them the more valuable they become. So what happens when you get to a point when you want to make a shift in how you collaborate? 

For example, there are a few reasons an organization may want to move from SaaS to on-prem or vice versa and while it isn’t common, it shouldn’t be impossible, either. And if it isn’t impossible to do, the odds are the work in accomplishing that isn’t trivial. Moves like this should not only be possible but relatively easy to do.

And then there’s our friend “vendor lock-in”. You should never get into a vendor relationship that you can’t easily get out of. The upsell models makes switching out solutions even more costly, time consuming and error prone. Worse yet, if you have independent vendor solutions each itching a specific scratch, then it means those integrations will break requiring more time to keep them in sync.

What’s Irking You?

It isn’t all doom-and-gloom when it comes to collaboration software, but a solution that is right for you NOW may not be able to grow with you in the future. To that end, it’s important to understand where many of today’s systems fall short, and make choices that balance where you are today, and where you want to go. Do you have a collaboration solution driving you crazy? We’d love to hear the reason why your collaboration solution sucks.

Signs That You’ve Outgrown Github, Part 3: Merges

This is part 3 in a series about the limitations of Github, and how they might be holding your team back from its full potential. If you want to go back and catch up, here’s Part 1 and Part 2.

Go ahead, I’ll wait right here.

Done? Okay, let’s move on.

Today’s discussion is about getting code merged. It’s one of the most fundamental things any software team has to do. If your team is anything like ours, it’s something you do many times every day. It might even be the kickoff for your Continuous Integration/Delivery process, as it is for us.

Reliable merging is the key to getting multiple things done at once

Getting things out quickly is important, but preventing outages from bad code is even more important. You probably want an easy way to review and even test code that doesn’t distract too much from the work you’re already doing.

Once again, Github has a wonderful system for promoting code from one repository or branch to another — the Pull Request (PR herein). In particular, the PR is great for open-source projects where people might want to contribute, even if they’re not members of the main project. The proposed contributions can be examined by the main project member(s) and be pulled in only if they’re helpful.

Typical Github pull request — you can see the code changes and their purpose, all in one place

But like many other Github features, you may find the PR process to be mis-aligned to your needs, in a way that creates a little extra delay and a bit of confusion every time you use it.

Pull Requests 101

For those who haven’t tried one yet, a pull request (PR) is a special kind of task, asking someone to merge a set of changes (commits) from one place to another. In more general terms, you can think of it as promoting a chunk of work from one level to another — such as from a development branch to test and then to production, or from a hotfix branch to long-term-support.

A simple example of promotion — taking a specific change from one environment to another

Because it’s a request, it doesn’t involve any access to the project repository from any non-members. The project team can review the proposed changes and take them, ask for revisions, or ignore them. It’s a great model for open-source or otherwise loosely-coupled groups to share ideas and improvements.

Keep It In One Place

But that flexibility comes at a cost. Pull Requests are opened and managed separately from individual tasks, so you’re basically creating another task to review each task’s work. The open or closed status of each task can be independent of the status of the related PR. Additionally, there’s nothing stopping someone from submitting changes for multiple tasks in one PR, which can be confusing and difficult to review.

For software teams that aren’t open-source, this loose coupling actually creates more process, more overhead, and time thinking that could be spent doing instead.

Ask yourself — wouldn’t it be a lot easier to merge the code as an integral part of the task itself?

Singularity Of Purpose

Let’s start with an assumption — that in order to change your code, there should be a defined reason for doing so.

You’re writing code because something needs to be added or fixed. There’s a use case. A story. A bug. A feature. A customer who wants something. There’s a reason to change what you already have.

You probably also want to do two things with your tasks:

  1. You want to create a plan ahead of time, for which things will be done, by whom, in what order.
  2. You want to keep track of progress as things move along.

Once you start depending on tasks for planning and tracking, you can begin to improve your overall process, reducing the number of steps and the distance between idea and working code. As you do, separate PRs may start to lose their appeal. Asking developers to open a separate kind of ticket to get code merged is a hassle. Allowing them to put multiple bug fixes into one merge is asking for confusion and mistakes.

If you’re delivering code using a well-defined workflow, PRs can actually cause problems:

  • Audit trail — It’s difficult (or impossible) to know later which code changes went with which task.
  • Larger merges — the code review itself becomes much more complicated, since there are more commits, more changes files.
  • All or nothing — If you like the changes for task #1, and for task #2, but there are problems with the tests for task #3, the whole PR is sent back for rework. This means you’re likely sitting on changes for longer.
  • More conflicts — Pretty simple math: (Larger merges) + (All or nothing) = More conflicts.

Since there’s no way in Github to limit the content of a PR, there’s no good way to prevent this kind of behavior. Creating a PR for every single bug becomes a tedious time-sink that doesn’t add value to your day.

Now, you might argue that a Github PR can act as the task itself, and it does — but not really. PRs are only retrospective, meaning that you create one after (or while) doing the work. If you don’t create tasks before doing the work, then you’ll never have any way of planning or tracking progress.

Simplify, Simplify

For most teams, the overlap between tasks and PRs is additional work that doesn’t generate any value. What you really need is a way to automatically detect code changes, review those changes and then promote them to dev, test and production, all as part of the task.

This kind of integration means that you can go back to the task later, understand the intent of the change, and also see the code changes that went with it. Your task tracking becomes a source of institutional memory, so that people can move in and out of the team, or across different features without making old mistakes over and over again.

If your tools are preventing you from improving your process, maybe it’s time to improve your tools.

Come try GForge Next for simple, comprehensive and elegant collaboration.