Visualizing Microservices & dependencies

The challenge

Applications that used to be large and monolithic are now being split into small and dynamic services. Microservice architecture allows developers (Dev) to deliver a lot more content, faster and more efficiently. In larger organizations it also allows creating a componentized architecture, and helps to clearly delineate which teams are in charge of which services.

However, often  organizations that adopt microservices discover that there are new challenges on the operations (Ops) side. The increased amount of components makes the system more complex and “nobody knows the big picture anymore”. Issues that span multiple services are even more challenging to troubleshoot and often multiple people have to be called in to help understanding and navigating the dependencies between the components in pursuit of the root-cause.

Visualizing Microservices and their dependencies, becomes a key factor in successful operations of the environment.


You should be able to answer questions such as

Regardless of if you are just starting with microservices or already have them deployed, you should be able to answer questions such as:

  • What are the relationships and dependencies between my microservices?
  • Can I visualize those dependencies?
  • Is my map of dependencies continually updating automatically?
  • Can I map relationships that are asynchronous in nature (e.g. messaging queues, scheduled tasks, asynchronous jobs, etc…)?
  • How do I quickly find or compare correlated metrics between two services (e.g. request latency in service “A” with CPU of service “C”)?
  • Can quickly I find or compare related metrics between components that are related but Nth degrees away removed?
  • Can I quickly monitor service KPIs without having to manually dive into individual instances or create complex queries?
  • In a super-dynamic environment, can I quickly review the historical behavior or a service even if some of its components are scaling or even replaced over time?


With ITculate, all this information is available to you using simple and clean visualizations of the architecture and its dependencies. We automatically identify all the components and how they interconnect.

Simply start from the level of your applications, traverse the relationships between and within services. Stop at the layer that is relevant to your issue and use our automatically rolled up metrics from the underlying dynamic layers. Review the automatically provided KPIs or add / remove metrics as needed. Metrics of the same type will be placed together on the same chart to make it easier compare resources. With ITculate, you do not need to call the experts into a conference. All team members are enabled with expert level information that is updated to the minute. Empower both Dev and Ops to do more and be on the same page.


Back to use cases

Start a free trial today