The 'Microservices architecture' of team work

For the past few weeks I’ve been helping a venture-backed startup adopt Clickup and a slightly milder version of my system.

Meaning they still have recurring calls and standups… but they’ve adopted the ‘everything as a task’ method. And while it’s not yet perfect.. it’s a pretty solid start.

Everyone creates tasks for what they are doing and update those tasks to reflect the work that they did on them. And everyone that is relevant to those tasks are following them and getting those updates.

I already see a lot of great coordination occuring through these tasks via the comments.

Plus i’m encouraging everyone to keep their Clickup notifications inbox clean every few hours and they’re doing a really great job at it.

I ‘co-pilot’ this process by adding myself as a follower to all tasks that are created, and so I can comment and encourage discipline to the process.

It’s only been a couple weeks… but already I am seeing what I call an evolution towards what I like to call “Microservices Architecture’ teamwork. And in this post i will explain what that is and why it is so powerful.

First let me tell you a bit about Microservices Architecture in Software

Microservice architecture in software has been a pretty big thing for a couple of decades now and most modern systems are built based on this approach these days.

Basically it means that instead of building one big interconnected ‘monolithic’ system, you build lots of discrete services and connect them (by API’s).

So instead of having a single database serving your complex application (eg. an ecommerce order management system), you have lots of small services.

And one benefit of this is that you can re-use a service for various use cases whereas in the past it would typically be relegated to a single use case.

For example I remember when I was looking at the order management system of Alibaba in 2016… I was impressed by their architecture, which basically enabled their team that built the order management system (OMS) for their e-Commerce company, Taobao, to also use this same OMS for numerous other businesses like their travel or their car sharing business.

Another benefit of this is that it allows you to scale complexity far better. Because you’re not building one massively complex system… rather you’re just plugging in more and more services. So if a new service that you plugged in breaks… you just turn it off. Without bringing down the entire system.

I try to apply these same principles to team work

When I think about how I want my teams to operate I try to achieve the exact same benefits as the microservice architecture I described above.

Each person in the team essentially provides a set of services. Each of those services is represented by a Clickup kanban board. And they execute the service via a task.

And similar to how a software application is built from a set of interconnected services, I execute projects through a set of interconnected tasks. They interconnect via the people that are executing them who comment and tag each other as they fulfill the tasks.

And similar to software this is a far neater way of scaling a business without complexity getting out of hand.

Because everybody is just focused on executing their set of ‘discrete services’ with just a handful of overall orchestrators (sometimes just me) who are making sure that the overall system works well.

Great visibility allows each person in the system to do more

Think about how most teams operate. The mantra is ‘focus’. Why?

Because the projects are typically built as monolithic systems. And so they need to focus on the highest priorities to make sure that those get done.

As a result in most teams many resources (ie. people) are not fully utilized. And in my experience the average true utilization of a person in any company is somewhere between 25-50%.

That does not mean they are not ‘busy’. They are still very busy because the project management is messy and they are writing inefficient messages back and forth with folks because visibility on tasks in other teams that they are dependent on is so poor.

Or they are writing and presenting useless ‘updates’ to one another.

In my system with clickup, they have great visibility into the status of those dependencies and so there is no need to ask the other person (eg. there is always an ETA on any task that is in progress).

Plus I often apply SLA’s on the execution of those tasks to keep the system running at a good velocity.

And I try to create systems that work almost completely devoid of writing ‘updates’.

This allows you to fully utilize every resource in the team

When you operate this way… you can put a lot more balls in the air. Because you know that each ball (ie. task) has a well defined path of its own and will land accurately without much time overseeing it.

Tasks cannot just disappear in my system. If they go overdue I get a notification and make sure it gets prioritised to get done asap.

For this reason I expect folks in my teams to be at a capacity utilization that is closer to 90%. As time goes on and the system gets more fine tuned… they are just throwing a shitload more balls up in the air.

Meaning our team can kick off a lot more projects that a similarly resourced, traditionally-managed team, would try to attempt. With the reason being that our system handles this complexity much better while still ensuring the highest priorities get done first.

I aim to get 2-3x more out of each person in my team than most other companies would

If you’re with me to this point… you should recall that I said that I aim to have each member of my team at ~90% capacity utilization whereas in traditional teams their true utilisation is around 25-50%. So i’m getting somewhere between 2-3x more out of each person.

And you would be incorrect to think that I am just pushing them more and making them work harder.

I go home on time every night and live a pretty stress-free life despite having lots of balls in the air. And I expect everyone in my team to eventually be doing the same.

How?

Simple. The system just starts working like clockwork.

The things that used to take up a lot of time because of coordination friction with others now takes very little time. You’re just tagging them in and they’re responding quickly and unblocking you.

Life gets easier. You get more done. And so you naturally want to take on more.

Closing thoughts

If you think about what I am saying above you should start to draw a similar conclusion to the one I have… namely that as you optimize systems they start to look very similar to one another.

If software handles complexity most efficiently as a ‘microservice architecture’ than it should not surprise you at all that the same will hold true of people.

Both software services and people do the same basic things…. we take an input and process it to deliver an output.

And in both cases you combine these services to create more complex systems (or projects).

The problem before was that we (as humans) didn’t have the right tools to be able to mimic software systems’ efficiency. But now with management tools like Clickup… I would argue that we do.

And the teams that ‘get this’ and leverage it… will beat the teams that do not.

I’m sure of it.