In the last decade, more and more companies switched their software architecture from a monolithic approach to microservices. A microservice architecture consists of multiple services that work in conjunction with each other to accomplish a higher goal. Since errors can now propagate through many different systems, it is advised to get a monitoring solution in place that covers all of these systems, and any root cause analysis will fall short if you have to stop investigating at the boundary of your services.

The question is, how can you solve this microservices monitoring problem? Should you subscribe to some managed service or build your own solution? How much money do you save by having an automated monitoring solution for microservices? In this article, we’ll look at the pros and cons of these two approaches, so you can decide for yourself which is the best fit for you.

Managed Monitoring for Microservices or Homegrown Solution?

There are many reasons to build your own monitoring services, but saving money usually isn’t one of them. When comparing a managed service with your self-built solution, many people tend to ignore the cost of labor. Also, the cost of your homegrown solution doesn’t just include a fixed fee you pay every month. It’s a function of the number of people working on it multiplied by the time put into it, and this includes building and maintaining this new system.

On the other hand, the cost of a managed solution isn’t just the monthly subscription fee. It’s also the number of people operating it and how much time it takes them to do so; but in this calculation, the monthly fee covers building and maintenance.

Let’s go over the different cost points involved with both types of monitoring solutions.

Building Time

If we assume that the requirements are already gathered for us, and we just have to start implementing them, the cost of building a homegrown monitoring solution is equal to the number of people building it multiplied by the time spent doing so. This includes the time needed to design the architecture, implement the whole system, and test it.

Of course, the cost of this solution must also include the time needed to wait until it’s finished. While the system is being built, you don’t have any monitoring and can potentially miss errors in your microservice architecture.

A managed service is usually already built when you want to use it, so it can be integrated right away and start notifying you of potential problems very quickly. The monthly fee you pay for it covers the development and maintenance costs as well, so you only have to pay for the people that handle its integration and operation.

Depending on the quality of the managed service, integrating it and operating it can become quite expensive, so it’s a good idea to try the service out before switching to it 100%.

If you want to look deeper into the costs of building your own solution versus subscribing to a managed service, this article is a good read.

Onboarding Time

Another vital cost point is onboarding time, that is, the time it takes to educate the people who need to use the monitoring solution.

Your solution can have very short or long onboarding times, depending on multiple factors. On the one hand, if all the people who built the system are also the ones who are going to be using it, then they’re already on board. But if they have to train other people to use the system, it’s a question of how many have to be trained and how good the trainers are.

A managed service always takes some time for onboarding, and all new users of the system have to invest time to get to know it. But the providers of the managed service are already used to this fact, so the chances are good that they supply their customers with high-quality documentation and training materials for them to get up and running fast. Of course, if their training material isn’t right and the documentation is lacking, this can lead to high onboarding times, so it’s recommended to check these out as well before signing any contracts.

Epsagon, for its part, comes with detailed documentation and a getting-started guide that can be found here, allowing you to evaluate its quality before paying a dime.

Maintenance Time

Maintenance time is the time spent updating a system and fixing its bugs. 

In a homegrown solution, this is 100% shouldered by you. Building and running your monitoring system is like building a new product, so it comes with many of the same costs involved. You have to fix bugs in your monitoring system and update all the libraries it uses. 

Infrastructure for your monitoring also has to be set up and maintained. If the system needs to scale up and down over time, you have to build on top of some infrastructure, such as virtual machines or container clusters. And all of these subsystems need operating systems that, in turn, need their own updates. Plus, databases may be needed, too. This can lead you down a rabbit hole you didn’t originally expect, and suddenly you’re putting more work into a supporting system than into the actual product you’re trying to sell.

A managed monitoring service incorporates maintenance time into the monthly fee, meaning, the monitoring gets updated and, in turn, is often better over time without you doing much of anything. Only if an update breaks the public API of the monitoring system, then you have to update your microservices to keep things going; but that’s it. The whole infrastructure, including servers and networks, is managed by a company that considers this work to be their main value proposition.

A fine-grained list of the pros and cons of managed services, in general, can be found in this blog article here

Troubleshooting Time

The time required to find and fix problems in your software is what an integrated monitoring system should decrease. Being notified about problems, locating them in your stack, reproducing the problem, thinking about a solution, and implementing and deploying that solution–these all can take time. Often, the solution is a simple and clear action, and the greatest part of this chain is simply finding the problem.

Monitoring microservices isn’t an easy feat, and building a high-quality solution for yourself can be as elaborate as building the software product you’re trying to monitor in the first place. If this endeavor is too different from the core competencies of your developers, it can lead to a sub-par solution and higher troubleshooting times.

For a service provider, on the other hand, the monitoring solution is the product. They’ve built and tested their solution on multiple systems of their own customers, and, in the process, they’ve come across numerous edge cases and know what worked and what didn’t in terms of performance. Because of this experience and know-how, they can tell you their performance characteristics even before you start using their service.

Tracing Visualization by Epsagon

Tracing Visualization by Epsagon

Here in this article where you can learn more about a technique called “distributed tracing” used to build a high-performance monitoring solution that follows a request through multiple services.

Microservices Monitoring Cost

Having an integrated monitoring solution for your microservice architecture is crucial if you want to run a successful SaaS company these days. Using different solutions for different parts of the system leads to more context switches for the operations team and, in turn, higher troubleshooting times.

Using a managed service to take on this problem can be a big help if you don’t have the manpower to build, operate, and maintain such a system. Let’s review the benefits of this option: 

  • It already exists when you want to use it.
  • It comes with educational material to get your people up and running.
  • It’s built on the knowledge gathered from monitoring many different types of systems.

Building your own monitoring solution can be a good idea, too. Here are the pros of choosing this route: 

  • It can be built according to your needs.
  • If the team that built it also runs it, onboarding isn’t needed at all.
  • Integrating your own monitoring can be easier than using a third-party service.

Choosing which monitoring solution is best for you isn’t easy, but your requirements will most likely lead you in one direction or the other. The considerations listed in this article can be a good starting point for you to get going on your journey.

We invite you to experience Epsagon‘s automated monitoring solution for free and decide for yourself.

Read More:

Observability Takes Too Much Developer Time, So Automate It

How Much Does AWS Lambda Cost?

Tagging Traces in Distributed Applications

Finding Serverless’ Hidden Costs

How to Avoid Cost Pitfalls by Monitoring APIs in AWS Lambda