Sign up to the Arctiq Newsletter to stay up to date on the latest blogs, events and news
Subscribe to Newsletter
An outlined icon of an X
left arrow icon
Back to Blogs

That isn't an App, It's Three Raccoons in a Trench Coat: Decoding the Power of Microservices Architecture

Like many Canadians of my generation, my first experience with Raccoons was the Saturday morning TV show (Les Amis Ratons for those in Quebec) but they also became a part of my daily speech in recent years. No, I am not talking about calling them Trash Pandas but I do find that adorable. I regularly find myself referring to things as “That isn’t X, that is 3 raccoons in a trench coat” referencing a very dated internet meme.

Well today, we are going to use that to talk about microservices, applications, and monitoring. 

Imagine that you're looking at what appears to be a fully functioning, sophisticated application. 
It's seamless.

It's efficient. 

And it works! 

But what if I told you that it isn't a single application…

NO! It is actually three microservices dressed up in a trench coat, pretending to be one!

What we don’t realize is that Raccoons are everywhere, working around us. 

Just like with “The Raccoons” and looking back fondly, there is a habit of relying on the things from our past. I remember when landing pages were hosted on LAMP stack and when applications were always giant monolithic code bases, a simple bear in a trench coat we could say. There was only a need for that one code base running in a VM and if you needed to support more users, you simply spin up another bear and you add them to the lineup. 

It was a simpler time.

But just like the life lessons of a children's TV show, what you learned is not without value, the skills you have are just as useful when working with Microservices. But how does it even work?

The Raccoons: Understanding Microservices

Microservices, or our raccoons in our analogy, are self-contained units. Each one handles a specific task or function within the overall system, and they can operate and be deployed independently. They communicate with each other via APIs, forming a collaborative, efficient group.

Microservices architecture isn't about isolating these raccoons to work in solitude. Instead, it's about each raccoon specializing in its role, delivering unparalleled expertise, and, together, masquerading as an entire monolithic application. 

Together the Raccoons are stronger than they are alone, and in the coat, they can work together to create something larger than themselves.

Unmasking The Benefits (Raccoon Puns!)

Flexibility in Design and Development:

Just like each raccoon has its own unique set of skills, each microservice can be built using the technology best suited for its functionality. Different teams of developers can work on individual microservices, working with the language, framework, or database they feel comfortable using and iterating and testing their particular component without being locked into application-wide low-level choices.  

Scaling and Resiliency:

Microservices are like raccoons - they're adaptable and resilient!

With a conventional monolithic application, scaling the application requires either deploying additional copies of the entire application (if that’s possible) or deploying larger VMs or servers for the entire application. A microservices architecture allows you to design horizontally, deploying additional copies of a single component as required to meet demand. This allows you to efficiently manage individual bottlenecks without needing to oversize components that don’t need it - keeping costs down. And because the application is designed horizontally, boosting its resiliency against failure can be as simple as adding more raccoons.

If one function of your application needs to handle more load, you can scale just that microservice instead of the entire application. If one microservice fails, the others can continue to operate, reducing the risk of complete application downtime.

Faster Deployment and Updates:

With a microservices architecture, individual raccoons can climb in and out of the back of the trench coat without causing problems to the coat as a whole, they can go on missions to bring things back for the other raccoons. 

Because microservices are connected only via APIs, they can be versioned independently. Any single raccoon can go get a snack on their own before climbing back inside the trench coat - he doesn’t have to try to get their friends to go to the garbage can with him. 

But it isn’t just the raccoons the trench coat can be adjusted, or even replaced entirely, without disturbing the raccoons. Each microservice can be deployed, updated, or rolled back independently, accelerating time to market and enabling frequent updates.

Simplified Troubleshooting:

In a monolithic architecture, a snag in the trench coat could mean a lot of effort to find which raccoon caused the issue. But in a microservices setup, each raccoon is accountable for its own actions, simplifying the troubleshooting process and making it easier to maintain and enhance the system.

The Trench Coat: Understanding What Is Shown To The World

Within the trench coat, each raccoon is an individual. But in order to fool the world, they need to work together. The trench coat is the unified experience that your application shows the world.

Your users don’t care about your application design; all they want is something that meets their needs and provides value. They only care about the trench coat: does it move like a person? Talk like a person? Gesture like a person? Can it pick something up and hand it to them? Great! That’s a success, even with its grabby badger hands.

But making it work isn't just about having a seamless UI. It’s keeping the raccoons focused on a single goal and working together to give a fantastic user experience. Each raccoon plays an important part, but the trench coat serves as an integration and orchestration layer for your microservices. The raccoons need to be able to talk to each other; they need to know that if the raccoon on the left hand is reaching for something, the raccoon on the right-hand needs to be ready to grab it, too.  

So what goes into a good trench coat? Two core things:

A Powerful Orchestrator

Trying to wrangle raccoons is a lot of work, and teaching them to work in the coat isn’t always easy. You need a powerful raccoon at the top to look after and command the other raccoons.

If one runs off to rummage through a garbage can, you’ll need to be ready to deploy another to take its place. If demand spikes because of a viral marketing campaign, or you have a predictable traffic spike you’ll need to be ready to scale out to more raccoons so your users don’t notice any slowdowns. That orchestrator needs to make sure not only that there are raccoons in the right place when they’re needed, but also that they have access to the right resources and are getting the instructions they need - with load balancing, storage, and networking functionality. 

Deep Observability:

What is going on in the coat? How are they walking around and grabbing things? Are there any problems inside or with the coat? 

Being able to deploy additional raccoons on demand isn’t helpful unless you know when they’re needed. Is one raccoon sick? Is another overworked? Sure, a microservices architecture lets you scale out to new raccoons as required - but how do you know they’re required?

Observability is key to any successful trench coat operation. Luckily, that can actually be easier with many raccoons: each individual microservice can be instrumented with health checks and performance monitors, giving you granular and specific information about what’s working and what isn’t, where there are bottlenecks, and where potential failures are likely to happen. We have to keep the raccoons healthy and working together after all…. or the humans will figure it out.

You also want to make sure that you are keeping up appearances, are you offering a good user experience, are you doing those things at a reasonable cost? These are all things that with proper instrumentation and configuration will allow you to continue to maintain the ruse of being three microservices in a trench coat, as well as have happy end users and happy stakeholders.


So, the next time you think about building a monolithic application (a bear), remember the three raccoons in a trench coat. The microservices architecture, just like our raccoons, offers flexibility, scalability, faster deployment, and simplicity, making it an excellent choice for modern, robust applications. While it may not always be the right solution for every situation, understanding the benefits can help you make a more informed decision. After all, sometimes, three raccoons might just perform better than a single, albeit large, bear.



Findlay Hilchie

Business Development Manager
View Author Profile

Related Posts