Peer-checkins to combat loneliness in a fully remote company

In this post, I am sharing the concept of ‘peer-checkins’ that Qxf2 (a fully remote company) has been using to combat the loneliness that comes from working fully-remote. A ‘peer-checkin’ is a 15-30 minute/week talk with a group of colleagues that is completely non-technical. It is similar to a water-cooler conversation at a co-located office. I am outlining the rules and structure within our company for peer-checkins. You can modify them to suit your context.


Background

This idea is not mine. It is something that multiple Qxf2 employees have contributed to. I banned 1:1 technical communication within Qxf2. My colleagues Rohan Dudam and Shivahari P complained that personal chit-chat stopped and that they felt isolated. As a response some combination of Avinash Shetty, Rajeswari Gali and me came up with the idea of a ‘peer-checkin’ – a short 15-minute call with a different colleague every week. The original activity has been significantly modified and expanded by my colleagues Smitha Rajesh and Rohan Joshi to include groups and some fun game/activity as part of the call.


Our rules for peer-checkins

These are the rules for peer-checkins that we currently (Apr-2020) use:

1. A ‘peer-checkin’ is a 15-30 minute talk per week with a group of colleagues that is completely non-technical.

2. The goal of this meeting is to make sure you have the kind of non-technical conversations with your colleagues in a co-located office.

3. You should treat the other person as your peer and not as your junior or senior. The ‘peer’ in ‘peer-checkin’ comes from the fact that you are treating the other person at exactly the same level as you irrespective of their designation.

4. During the call, you can discuss how your week is going, what is on your mind, advice on any common problems your group faces, anything fun you want to share or just play some game.

5. The call should not be about status updates or technical help.

6. This call requires zero preparation time and you should not have to go into it feeling guilty or burdensome.


How to pick groups randomly?

If you do go down this route of implementing peer-checkins, you will need to assign fresh groups every week to avoid the formation of cliques within your company. This part of the post will show you how to randomly break your large teams into smaller groups using Python. You can use this script if you have N colleagues and you want to break them up into groups of k-people.

To use this script:
a) Update the EMPLOYEES variable to list your employees
b) Run the script with your desired group size: python grouping_people.py --size 6
c) You can get the entire file in this GitHub gist

"""
This script is an example of how to pick groups of 'r' people randomly from within a larger sample of N people such that no single person appears in two groups.
I find this script useful when I have to divide my employees into groups randomly
"""
import argparse
import itertools
import random
 
#Note: Listing employees just to keep the example short
#You would (ideally) get a list of employees from some central datastore
EMPLOYEES = ['Wilhelm', 'Emmanuel', 'Jose', 'Alexander', 'Max', 'Mikhail', 'Vassily', 'Tal', 'Tigran', 'Boris', 'Bobby', 'Anatoly', 'Gary', 'Vladimir', 'Anand', 'Magnus']
 
def check_no_overlap(my_tuple, reference_list):
    """
    Verify if at least one member of a tuple overlpas with the members in a list of tuples
    :return result_flag: boolean
    """
    result_flag = True 
    for reference_tuple in reference_list:
        result_flag &= set(my_tuple).isdisjoint(set(reference_tuple))
        if result_flag is False:
            break
 
    return result_flag
 
def get_groups(group_size):
    """
    Return groups of size group_size
    :return groups: list of tuples
    """
    unique_groups = []
    expected_num_groups = int(len(EMPLOYEES)/group_size)
    #We shuffle the combinations to keep the order fresh everytime
    random.shuffle(EMPLOYEES)
    if group_size >= len(EMPLOYEES):
        unique_groups.append(tuple(EMPLOYEES))
    else:
        #all_combos is a list of all group_size combinations
        all_combos = list(itertools.combinations(EMPLOYEES, group_size))
 
        #Our next step is to make the groups disjoint
        #'disjoint' = One employee cannot appear in two groups
        for combo in all_combos:
            if check_no_overlap(combo, unique_groups):
                unique_groups.append(combo)
            #A small optimization is to stop checking combos once we reach the expected number of groups
            if len(unique_groups) == expected_num_groups:
                break
 
    return unique_groups
 
#----START OF SCRIPT
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--size', dest = 'size', type = int, default = 2, help = 'Size of the group you want')
    args = parser.parse_args()
    if args.size < 1:
        parser.error(f'Invalid argument --size {args.size}. Group size should be an positive integer.')
    groups = get_groups(args.size)
    if len(groups):
        print('Groups chosen are:')
        for i, group in enumerate(groups):
            print(f'{i}. {group}')

The key lines of code happen to be:

a) itertools.combinations which generates all possible combinations of choose ‘r’ items from a list of ‘N’ items
b) .isdisjoint() operation on two sets to ensure that no single employee is part of two groups


Learnings, observations and results

1. We have much better employee engagement than before.
2. I see more humour in our common channels.
3. Mandate peer-checkins but keep an expiry date for the experiment.
4. We found a group of 4-5 people is ideal for a peer-checkin.
5. Ensure that it is completely ok for folks to drop out after the initial mandated period.
6. Make sure everyone stays non-judgemental about people that drop out of peer-checkins.
7. Remain non-judgemental when these people want to rejoin peer-checkins.
8. Don’t let groups self-select. Instead group them at random every week.
9. Once the peer-checkins start getting boring, people evolve and find group activities to make it interesting
10. Most engineers enjoy bonding when it happens in the backdrop of a problem or puzzle to solve.
11. It is preferable to leave one or two members out every week. This has the benefit of giving those members a break from peer-checkins.


If you tried peer-checkins or have questions about it, drop a line in the comments below.
 
P.S.: Those names I have used for the EMPLOYEES in the script? They are the names of the 16 world chess champions. 15 are first names. I had to use Tal (last name) since his first name Mikhail was already taken by Bottvinnik.


Arunkumar Muralidharan

I want to find out what conditions produce remarkable software. A few years ago, I chose to work as the first professional tester at a startup. I successfully won credibility for testers and established a world-class team. I have lead the testing for early versions of multiple products. Today, I run Qxf2 Services. Qxf2 provides software testing services for startups. If you are interested in what Qxf2 offers or simply want to talk about testing, you can contact me at: mak@qxf2.com. I like testing, math, chess and dogs.

Be First to Comment

Leave a Reply

Your email address will not be published.