After 20 years and a global pandemic, we learned that ‘hybrid remote’ is exactly how software development teams were always meant to work. That is, teams working collaboratively across different locations, time zones, etc. and completing individual tasks asynchronously that are dependent upon one another.

Ever since the Agile Manifesto was published in 2001, software development has gone through some drastic changes. Most recent examples include the adoption of asynchronous communication tools (e.g. Slack & Teams), which created a new default communication style for businesses. The pandemic also forced work from home policies to change abruptly and the need to hire remote developers and connect remote teams increased dramatically. 

Many developers and dev team leaders invited the idea of working remotely because it meant less interruptions and more time to focus on tasks at hand, right? Not so fast…

Just because individual productivity can go up doesn’t mean dev team efficiency follows in step. In fact, when the entire global dev community went remote at the same time, did businesses go through the exercise of redefining the ways of working remotely? If not, there’s a good chance the “in the office” mindset crept back in at some point and interruptions remained. 

Zoom meetings, impromptu daily status updates and plenty of other distractions keep dev teams shackled away from their deep state of focus. The past year put a spotlight on the need to transform the hybrid remote reality into an opportunity and strengthen the alignment between dev teams and the business.

Hybrid remote development is not new, but 2020 accelerated the adoption of many of the practices already in place. As these hybrid remote methods are normalized globally, we also have to accept the way we work, the processes, and the ceremonies have changed as well.

This is how Asynchronous Development (Async Dev) was born.

What is Async Dev?

Async Dev builds on the foundation that Agile and DevOps put into place. It is an approach to software development grounded in asynchronous communication. It works for hybrid remote, full remote and any dev teams aiming to unlock the full creative power of their developers. In order to unleash this power, Async Dev presents five guiding tenets:

1. Asynchronous is the default form of communication: Asynchronous communication means using collaboration tools and mentions by default. It helps reduce context switching, avoid unnecessary interruptions, and increases productivity. 

With asynchronous communication, it is vital to analyze your dev team’s metrics to understand exactly how this change affects the productivity and efficiency of the team itself. For example, if more code is being written as devs work from home, but pull requests and cycle times are increasing, you need to find out why.

Tip: Examine the function of the daily stand-up and figure out how to best use that time to suit your team. As a hybrid remote dev team, create a way to get a shared view of up-to-the-minute updates on issue statuses but use stand-up time to connect on a personal level, and talk about blockers. 

2. Git is the central element of your development process: Whether you use GitHub, GitLab, Bitbucket, Azure DevOps or another flavor of git, most of the stages of the dev cycle either start or involve your Git system. The choices made to configure, deploy and utilize it has a great impact on your dev process.

In addition, the most up to date status of work progress resides in the git system. Since Git was built on the principles of open source, most phases (coding, review, merge) do not require mandatory synchronous communication and can be executed in different places and different times.

Tip: Master your configuration and choose your policies with hybrid remote dev teams in mind. Remember, the best data sets for understanding progress or where we are as a team working on a project are extracted from Git.

3. Use Project Management tools for planning, not status updates: Whether your team uses Jira, Trello or something else, project management tools are great for planning an iteration. Trying to use them to enrich dozens of micro decisions that dev teams are taking every day only slows down productivity.

Every work status update while in ‘building mode’ should be considered with dev first in mind. Make every update automatically reflect the status based on actual git activity and allow it to serve the people that build and ship the software.

Tip: Project management tools should not be used for software delivery predictability. The minute you switch from the planning stage to the building stage, you should use a different tool or approach.

4. Continuous improvement is a daily practice: Data should always be accessible to everyone on the team, not just data engineers. This information should also not just be reviewed in meetings by management or held by gatekeepers. Your culture is defined by the KPIs you set and how you decide to utilize them. The key principles for data usage for Async Dev are:

    • Team-based data over individual developer stack ranking
    • Measure process instead of output
    • Measure empirical data over subjective data
    • Focus on leading indicators vs. lagging indicators
    • Establish baseline data points and trends
    • Make sure it’s actionable

Tip: Data should be used ethically and cannot replace good managers with good soft skills and human interactions. You can’t optimize what you can’t see so leverage the principles above to frame how to measure and what to measure. Most importantly, just measure!

5. Dev teams are the core of the business: The best companies in the world today evolved from developers that were highly aligned with business and market needs. Dev-led companies empower developers to make the best decisions on behalf of customers and the business by enabling context instead of giving instructions. 

Developers and the business should never be disjointed and sometimes the most important business decisions are hiding in the lines of code. A focus on pushing context to dev teams provides a way for them to create transparency into decision making so everyone can participate in a refinement cycle.

This is probably the hardest part of making Async Dev a reality because, as dev leaders, it is the element of  least control and requires buy-in from throughout the business.

Tip: Make every developer a decision maker. Create and nurture shared insight into development data in order to make business decisions transparent and daily collaboration across functions routine.

Hybrid remote can be a business advantage for companies embracing it, but only if we adapt our culture and process to align and make it a reality. Big changes took place last year and now is the best time to go through the exercise of redefining how you work. After my co-founder, Ori Keren, and I decided to start a full-time remote work policy for LinearB in March 2020, we did just that and created Asynchronous Development. 

We view it as a dev methodology designed around asynchronous communication and purpose-built for hybrid remote teams. It’s our favorite parts of Agile, a little bit of Scrum and incorporates a lot of what Ori and I have learned over the years as engineering leaders. Async Dev creates a mindset for where we think the future of software development teamwork is headed.