Collaboration and Parallelization
Tags: productivity, collaboration
Published: 2021-02-26 11:39:13


Collaborating on a task is great. Here's just some of the benefits:

- Having more eyes on a problem helps us work faster. Another human might spot the problem causing a bug we missed, avoid unnecessary work, and help us avoid getting stuck in rabbit holes.
- Hearing more voices when making a decision improves the quality of that decision. The earlier we get those voices in, the less rework we have to do.
- By having more ears in the room we can bake context-sharing into the development process, and reduce the need for separate meetings, processes, and roles dedicated to alignment.
- Some of our hard work can be draining. Sharing painful tasks can help keep us motivated.
- Collaborating on tasks means we need fewer tasks in progress at the same time. This means our backlogs can be shorter, which has benefits of its own that [I wrote about previously][backlogs-arent-free].

I think most people (including me) don't feel like collaborating on tasks 100% of the time. I need time for myself as well. Given the advantages above though, it seems worthwhile to continuously look for ways to collaborate as much as possible, as long as it's sustainable.

This goal of collaborating more can be at odds with another popular goal: to parallelize work as much as possible.

If we create a large backlog of tasks ready to pick up then we intentionally make the barrier to starting new work _very_ low. Starting new work takes less energy than gaining context on an in-progress task and supporting a colleague.

When I created backlogs like that I think it was primarily out of fear that without sufficiently parallelized work someone on the team (myself included) might find themselves with nothing to do. Never mind I couldn't even imagine what it would be like not to know a single useful thing to do. Never mind that having some slack in our schedules for small refactoring tasks and the like makes us more productive rather than less. Any stretch of time between an individual running out of work and the team deciding a next step seemed unacceptable.

There is a self-reinforcing feedback loop here: If we're used to picking up new work over helping finish in progress work then running out of new work is a big problem. By addressing the problem we further encourage ourselves to start new tasks.

One way to break out of this loop is using a work in progress limit, a maximum amount of tasks the team can have in progress at the same time. When at the limit an in-progress task needs to be finished before a new one can started. Retro on what the biggest obstacles are on setting the limit lower and try to remove them. A work in progress limit will force us to work on fewer things at the same time without having to give up the curated backlog (which is scary!).

Here's another self-reinforcing feedback loop incentivizing parallelization: As we practice collaborating on tasks our toolbox of collaboration strategies gets fuller. Until we have a full toolbox a lot of upcoming work can look unsuitable for collaboration, causing us to parallelize it preemptively and robbing ourselves of the opportunity to learn.

We can break this loop by committing not to parallelizing preemptively. This means accept some amount of pain and trying to find collaboration strategies to address that pain. Maybe it doesn't work and you'll fall back to parallelizing anyway. That's fine. The important thing is to try collaboration first.

How much do you collaborate on your team? How much do you parallelize work? Do you experience any tensions between the two?

[backlogs-arent-free]: https://dev.to/jwoudenberg/backlogs-aren-t-free-332d