Working with virtual teams is a big trend in the software development industry, as the globalization of labor is the only viable way to scale the growth of the sector. New technologies in virtual reality, high-speed Internet connection and communication tools open exponential options for virtual collaboration, and will reformat what globalization looks like. In the future, you’ll be able to sit in a meeting room anywhere in the world with whomever you’ve organized that with. You might not be able to shake their hands, but here are the best practices – and tips – on how to best work with those virtual co-workers:
1. Scope: go through all edge cases
When developing a product with a virtual (remote) team, it’s critical to make sure all parts are in tight sync before making big decisions. Since you don’t have the occasional chat “around the water cooler”, as Harvard’s Michael Watkins cleverly explains, small misalignments – usually caused by team members having different understandings of how the product should behave in specific situations – grow at an extremely fast pace.
Make sure you and all the virtual collaborators understand what should happen in every situation that your product can go through. If you are, for instance, developing a mobile app, make sure that all buttons have clear and understandable actions. All the screens should gracefully deal with bad – or no – Internet connection at all. Your features should handle lack of permissions (from camera, GPS, address book, etc), and you should make sure that all screens are mocked-up – or at least wireframed – and that there won’t be anything that could block the developers from moving forward or, even worse, that could make them implement something incorrectly . Creating a functional flow of mobile and web apps in a tool like Invision or Proto.io is a great way to have a nice shared understanding of the scope, and also allows usability tests to get started.
The most important moment to pay attention to scope definition is when kicking off a new project or feature – or when creating/reviewing quotes to start a virtual working relationship. Make sure to have some initial estimates in hand – from Estimate My App for instance – since it’s often common for contractors to send cheap and fast estimates without making any questions regarding the project scope, just to close a deal quickly. At those moments, it’s great to remind ourselves about Admiral Ackbar, from Star Wars:
It’s impossible for someone not to have any questions, and it’s organic and healthy not only to solve them, but also to suggest changes when you disagree with the answers. You want a remote team that participates and gives its opinion, even if it isn’t exactly their area of expertise. For instance, engineers should question – and brainstorm with – UI/UX designers and vice-versa. In the development-design brainstorms and discussions, it’s always great to check out tech stack directories, like StackShare, to make sure your technical expertises and design expectations are well-aligned.
Last, but not least, when scoping design tasks – or simply explaining the product’s functionalities and UX – use lots of references. You’re expected to be an expert in the field – or in the most similar ones – that you are working at, and naming existing products is a great way to cross borders and reach the understanding of co-workers with different cultural backgrounds. When the references don’t cover your exact ideas, use platform ground rules to make sure you’re in the right track. Taking the mobile industry as an example, Apple’s iOS Human Interface and Google’s Material Design guidelines will provide almost all the content you need.
2. Communication: keep in touch
When communicating with virtual teams, being available is priority number one, as Prof. Sebastian Reiche describes in his Forbes list. Since you won’t have someone sitting right next to you all the time, finding a communication channel that replaces this in-person interaction is key for the process to work well. Having an agile culture with fast iteration cycles is core to staying in sync. Using customizable communication tools, like Slack, to keep in touch with each other, while also automatically aggregating other apps (like Github, Trello, Jenkins, Travis CI, IFTTT and so many others), is a great way to remove as much friction as possible when distributedly dealing with code development, task management, continuous integration and interfacing with other services and devices.
Regarding meetings, video chats are a great way to get closer to the person that is – or will be – working with you. Getting in touch with the virtual co-worker’s presence and understanding that person’s reality, how the workspace that they’re working at is, how the weather in their city is like– and so many other things – is an amazing way to create a more meaningful relationship, be more productive together and build even greater solutions. Adding a meeting to Google Calendar makes sure that there isn’t any confusion regarding time zones and also creates a Hangout link for everyone to meet at.
When talking and getting to know foreigners, don’t exaggerate on local expressions and articulate nice and easy. Sharing meetings notes right after they’re over with conclusions, action items (and who’s responsible for each) and observations is effective in making sure no big idea was lost in translation. In longer virtual working relationships, having an in-person chat – or a trip visit to work together for a week or so – is an awesome way of making sure all sides are aligned for future goals, and that the strategic plans are well spread throughout the team.
3. Documentation: automate it
In the software development industry, especially when building web and mobile applications, it’s common to have at least one interface protocol – usually Restful HTTP APIs – that dictates how an iOS app, for instance, communicates with a server that retains all information and connects it with the other platforms. It’s critical to have all the APIs well-documented, at GitHub for instance, and even with mocked response payloads in a dummy server, like on Apiary, so the teams that are building the client apps (e.g. web and mobile) don’t get blocked.
Once it comes to interfacing with remote designers, using a software that creates a nice experience for developers to get information about sizes, colors and fonts from wireframes and mock-ups, as well as to automatically export all visual assets in different formats and resolutions, is a must-have. Zeplin fits that profile by providing an interactive interface that displays all exported assets, together with the mock-ups in a nice and minimalist experience. Zeplin works flawlessly with Sketch’s slices, so the designer has a nice and organized vectorized view while the dev dynamically interacts with informative mock-ups and also gets the assets in all necessary resolutions, in a click-to-download way.
4. Versioning: grow your project tree
Building software products requires organized versioning repositories and processes, and to replace physical side-by-side code reviews and pair programming, it’s great to have an organized Gitflow with pull requests and rebases. Screen-shared pull request reviews, together with virtual team members, are a good practice to align code styles and make sure everyone has a nice understanding of how the codebase is growing. Using Bitbucket and GitHub‘s in-code comments is a scalable way of keeping the review conversation alive when the real-time chats aren’t needed.
Besides making sure you have a nice and clean versioning tree growing, GitHub allows creating issues (tasks) that can automatically be closed through special tags on commit messages, organizing those tasks into milestones (that are also dynamically updated when issues are finished), building wikis to better explain how to use and set up the codebase, integrating continuous integrations systems, and much more.
Incorporating continuous integration solutions – like Jenkins or Travis CI – to your versioning system is an efficient way of automatically running tests and creating builds when new commits are made, notifying administrators of failing tests, calculating test coverage percentages and even deploying your application to the App Store or the Play Store, using Fastlane, for instance.
5. Task Tracking: prioritize the work
When tracking tasks with virtual teams, make sure to have one board – in Trello, Pivotal, Asana, Jira, etc – with all the issues that everyone is working at. Making sure all bug fixes, polishes and fine-tuning are represented as tasks in the board is a nice way to guarantee that the virtual collaborators won’t get confused in terms of tasks priorities and that – consequently – you’ll meet the deadlines. Having an organized and prioritized list of tasks allows the project not to have co-workers blocked by trying to figure what should be done next, and this is essential with teams that are working in different timezones and might not be able to ask someone what’s the next priority at a certain time of the day.
Translating action items from meeting notes emails into tasks, connecting the task tracker updates to Slack and also integrating them with GitHub commits, as described above, are ways to better interface the processes and reduce the possible overhead when organizing and writing down descriptions of what should be done. That way, the documentation content is created in phases, without bottlenecking any part of the process.
6. Feedback: be thorough
When interfacing with virtual beta testers, make sure the most amount of information is shared when a bug – or incorrect behavior – is provided. Using mobile development as an example, it is useful to know which device the tester had, which OS version was being used, what internet network s/he was connected to, and – the most important – how to reproduce it. By understanding how to reproduce a bug, the tester gets a better feel of how the implementation handles different environment variables and, with the detailed information, the developer is able to quickly fix and improve the codebase.
Using tools like Notificrash, Crashlytics, Flurry, Mixpanel and Google Analytics to track crashes, usage, installations, users and much more is a great help on making sure the development team can interface well with testers (and users). Make sure to add meaningful tracking events to the flow of your application to have better insights on how people are using it. Creating statistical funnels, heat-maps and scroll maps (Crazy Egg is great at doing that for web pages) is also important to validate theories about how users are expecting features to work, and what content should be presented at each stage of the product’s experience.
7. Motivation: make it awesome
One of the biggest challenges of nurturing a healthy working virtual relationship is making sure that all co-workers are motivated with the company’s vision and mission. In the short term, it is great to give extra compensations when milestones are reached with exceptional quality and productivity, and also to have periodic chats with all the team members, to align their personal goals with the company’s strategic planning. Middle-term wise, having yearly wages updates based on 360-degree feedbacks and promotions will make sure all collaborators are learning new things and developing their professional skills. In the long run, it’s critical for the collaborator to have some type of equity bond with the company, so that their desire for the organization’s success lives long- and meaningfully.
When it comes to virtual relationships between different companies, having equity agreements is still a valid option. Having a contracting company that owns stocks of the product is a big change in mentality when it comes to remote collaboration. The industrialist contracting model based only on hourly rates is broken in most of the cases. In the long run, it’s common in most contracting projects for the code to become messy, the usage of legacy technologies to grow and non-scalable issues start to pop out. Once you have an equity relationship, the company developing the software will start having the initiative of using the coolest technologies and creating a solid codebase, and even being more participative in brainstorms. This happens because now they aren’t only worried about the short term hourly rate, but are indeed caring about the success of the product: they’ve stopped being client and contractor, and have become partners.