What Project Tools are Missing

If you're building an app or website, you're likely using a tool to manage the process, such as Trello, Jira, GitHub Issues, or Pivotal Tracker. Some teams use a combination of these (one for big picture planning, one for specific tasks, for instance) and also incorporate more specific apps for design feedback.

Each tool has its own approach to tracking tasks and progress, sharing images and documents, and enabling discussion. Once you choose the best tool for your team and establish a workflow, you can turn your focus to building great products.

A few months later, it's common to encounter increasing frustration with your choice and start to wonder if you made a mistake. Conversations start happening in other tools, a Google Doc becomes the de facto backlog, and people start adding work to the project tool after they finished it. I've had this experience many times over the years.

Changing tools is rarely the right decision. I've seen teams fall into a cycle of evaluating, choosing, and discarding tools. We blame the tool for what are really team issues, poor processes, or simply a failure to be consistent. The better solution is often changing how features are designed, decisions are made, or progress is communicated. The tool has only surfaced the issue.

Tools could be better, though. They provide a centralized place for project tracking and discussion, but they do little to help with decisions.

What needs my attention?

In a large project, conversations are spread across many tasks. One person may be responsible for a task, but the discussion is where decisions are being made: from defining the feature initially and finalizing copy to debating design and implementation details. Inboxes overflow with notifications about these conversations, but unless you respond in realtime, it's very difficult to know where your attention is needed. Which update was just to keep me the loop, which is asking for my opinion, and which is waiting on my decision? Every comment is treated the same as every other comment.

What was the decision?

The result is that the only way to find the actual decision within a discussion is to read the discussion. Making it possible to catch up on the reasoning behind a decision is great; requiring that someone read through the conversation to find the moment when a decision was made is silly. Making it possible to close a discussion or mark it resolved isn't much help if the resolution isn't documented.

Plus, conversations often include more than one question and answers. Sorting through this is time-consuming. Are we waiting for someone else to vote? Which decisions have been made and which are still being debated?

The result is:

Time wasted going through discussions to see if you need to comment
Many people chiming in, but little clarity on decisions
Notification noise that makes it easy to miss things
The true status of a task is hard to discern, as the complexity and unknowns are found within the discussion

Smarter Tools

There are manual processes that help with each of these things. You might make sure that a story or task is small enough that lengthy discussion and multiple questions are unlikely. Anytime a decision is made in a thread, you could add special formatting and update the beginning of the topic, the story description, and/or the original spec.

But tools should be smarter, too. A few ideas:

Add different comment types, such as Question, Answer, and Vote
Provide the ability to assign a question to someone within a discussion, while still including others as observers or contributors
Require a summary when a question is marked closed or resolved, which is displayed next to the question, with the discussion hidden by default
Provide a dashboard view of discussions that are in progress, prioritizing those that are awaiting a decision, as well as ones that require a response from you

This is just a start. There is much that could be done to better support product management generally, from improving the feature shaping process to shepherding an idea from definition, writing, design, development, and testing to releasing and iterating.