Async Communication - Channels for a Remote Software Dev

date

Jan 29, 2024

slug

async-comm-channels-for-a-remote-software-dev

status

Published

Introduction

This post assumes you are already familiar with what asynchronous communication is and why you’d want to use it, if you’re working remotely as a dev. In this quick post, we’ll take a look at:

What the various channels are

Guiding principles for each channel; rather than itemizing all possible scenarios, which could be impossible in a dynamic business environment, my hope is that by sharing the general principle/best practice, you could use each in a variety of different scenarios

I’ll include examples to tie it together

Why This Post

Nowadays, it feels like we have access to 5 or more platforms where we communicate as a team. Thus, it seems appropriate to try to identify these different platforms/channel, and where each could play a role in facilitating communication within a team.

Channels

Overview

Before diving into each channel, I wanted to provide a couple of things.

First, by channel, I essentially mean the platform. For example, Slack is what I would consider a channel through which one can communicate, for the purpose of this article.

Second, I wanted to organize the various different channels as generic categories, since you might not use the same tools I do. Think of this as the TLDR of the channels I use on a daily basis, in case you want a quick reference:

Instant Messaging (e.g. Slack)

Video (e.g. Loom)

Task Tracking (e.g. Jira)

Email (e.g. Gmail)

Others

With that out of the way, let’s dive into each channel and guiding principles for where said channel is useful.

Instant Messaging

In the context of async communication, these platforms (e.g. Slack or Teams) are powerful and useful when your intended audience is or could be large — a “wide net” — and the communication is in written form. In other words, you have a question, or some general communication, and don’t need to tag any specific individual.

As an example, imagine you’re a FE dev (like me 😃), and you have a question about the backend, like what query(s) are available for some specific problem you’re solving. In this scenario, you could post that question in the backend channel without any specific mention.

The advantage here is that you crowdsource from and, at the same time, share knowledge with the team. The communication is open for all to see and answer. This maximizes your chances for getting an answer without disturbing someone.

This is a really neat technique for:

Getting answers to your questions from folks who can jump in

Getting feedback for your ideas that are not exactly tied to any specific ticket

Sharing summaries for certain issues, like bugs

Sharing links to videos and other resources in your knowledge base

Video

The main platform I am aware of is Loom. When to utilize this channel is pretty straightforward — use this when you need to communicate in video format, rather than text. This is typically the case when there’s too much to type and you need visuals to support your communication (e.g. some UI component or something like this).

I’ve run into two sets of audiences for this:

Targeted (e.g. for a specific person) - This is helpful for avoiding a meeting, especially with someone who’s halfway across the world. It’ll allow them to get all of the context as if we’re in a sync, without having to be in a sync. 😃

General - Like the principle shared in the instant messaging section, you can include links for a wide/general audience, if needed.

This remains a powerful tool in my tool belt for avoiding meetings.

Task Tracking System

The only platform I’ve used here is Jira, so my experience will reflect this. I utilize the comment section to tag specific people with questions/communications for a specific ticket when needed.

Here are some common scenarios I run into as a FE dev:

Design question, I tag the designer(s)

Product/requirements question, same, I tag the product manager(s)

You get the pattern. If you’ve got a concern related to a specific ticket and it’s for specific people, no need to use general channels in Slack, or similar tools. Instead, tag the relevant folks.

Email

This one is interesting; currently, I haven’t used it often, neither do my teammates. If there were team or organization wide announcements, emails tend to be the way to go. Essentially, large and formal changes have been nicely communicated via emails.

Some examples include:

Roadmap updates

Org updates, like folks getting promoted or moving on

I’ll say this as a FE dev, I do not use this channel; I can’t remember the last time I did, as I am not usually in the position to announce organization wide changes.

Others

In many cases, I’ve used other channels for communicating to specific people for specific problems. Here they are:

Figma - I leave comments next in the design, if my comment/question is regarding a specific component. I’ll make sure to tag the designer.

Notion - If providing feedback on a doc, of course, I’ll make sure to leave the feedback on the doc.

GitLab - Of course, the obvious use here is comments for merge/pull requests. Obvious but worth mentioning.

These are essentially the same methodology used in tagging people in ticketing platforms, like Jira. It follows - tag the person where is most relevant.

Conclusion

These are the main channels I use and how I use them. This is such an expansive topic; it’s virtually impossible to cover every scenario or channel. Much of this will vary from team to team, among other things. However, hopefully you got at least one valuable nugget from here!