Asynchronous (async) work is a way to organize the order in which tasks are executed in the pipeline of work. It allows you to fine-tune work so that pressure is even, tasks are completed swiftly and you stay nimble.
An even, swift, and nimble pipeline produces exactly the right quantity of output for its requirements, and all its stages are balanced in terms of efficiency and speed, resulting in no waste of time or resources. This is inspired by the Toyota Production System 3Ms methodology; more information about that is here.
Async work relies on three main tenets: Multiplexing, Communication, and Action.
Human beings exist in a synchronous world, we are bound by time moving forward one second at a time. However, the way we do things (or put things together) has an insane amount of impact on the outcome of our pipeline. It's all about planning.
Typical (synchronous) planning relies on kicking off things in a bulk fashion. On its own it's not a terrible thing to do, however, a system will go as slow as its slowest element. In this case, any delay will be propagated through the pipeline, as each stage depends entirely on the step that precedes it.
Example 1
This image represents a three-terminal software development pipeline organized with sync planning. To deploy a feature we need tasks A, B, and C to be completed. Given the way that these tasks were planned for and distributed we will require a cycle of 9 work hours per deployment. This is great for atomic tasks, but very slow otherwise as we'll only be able to deploy every so often.
Async planning relies on breaking tasks into smaller tasks as much as possible and releasing Minimum Viable Changes (MVCs) as frequently as possible. This technique relies on the hypothesis that shipping less but more frequently allows you to measure success and counteract any negative feedback as fast as possible. It also allows more fine-grained control of resource allocation as we'll be able to perform more tasks in the same amount of time (due to their reduced size).
Example 2
In this example representation, by separating Tasks A, B, and C in (A1, A2, A3, B1, etc.) we achieved three times as many deploys as in the previous example (M1). In this example at the end of the 9 hours we may end up with the same amount of features deployed, however, multiplexing our tasks with async task distribution we were able to release subsets of our tasks, thus being able to validate their impact, and rollback or reassess the next steps. We've reduced the iteration time to a third of the original planning.
This methodology allows us to do multiple tasks, combining them to produce results faster.
Good communication is key to the success of any system (human or machine).
There are many types of communication, such as email, a message, a voice call, a video call, or even a "let's go get a coffee". Each has a totally different impact on productivity and picking the right one is as important to the production pipeline as any other task we can perform.
Synchronous communication is the one we are most inclined to because it's easy and more comfortable in a way.
A conversation (usually) requires at least 2 people. An engaged conversation can take multiple forms: