Virtualization Technology News and Information
Are you helping your developers save time?

By Alon Girmonsky, CEO and Co-Founder, UP9

In today's competitive business world, companies worldwide continue to digitally transform.

Because of this, developers and engineers are under more pressure now than ever before.

Regardless of the industry, businesses worldwide are updating legacy systems, migrating content, adopting new technologies, constantly testing, and much more. They are also beginning to develop several microservices.

Years ago, things were not nearly as complicated. Now, developers and engineers are facing new time-consuming problems, such as:

  • An increase in microservices and API endpoints, making it hard to maintain documentation and causing developers to spend more time on service-to-service integrations
  • Decoupling microservices, which has introduced debugging and troubleshooting complexity that didn't exist before with monoliths
  • Component-level testing, which requires a lot of effort and is hard to maintain, flipping the testing pyramid and having GUI tests take a lot of the burden (which is too late)
  • Multi-protocols, such as REST, gRPC, Kafka, are used in a single backend flow, which makes it hard to understand backend flow and troubleshoot an issue
  • The amount of changes in the application (the sum of all microservices changes), which is hard to test as part of the build and catch functionality changes

Now that things have changed, many companies are trying to help developers save time, and help IT and business leaders save money.

Is testing broken?

As a developer of open-source and commercial applications, and through my decade-long journey working with enterprise customers enabling them to shift testing to the left, I came to the realization that testing may be broken.

Developers and engineering leaders are often building both commercial applications and open-source projects. This is why my colleagues and I noticed that traditional testing methods were inefficient.

Many companies have decided to do something about this, as they have dissected the new-age testing process down to the most granular details to see how we could rebuild it as a modern, autonomous alternative to traditional testing.

Let the machines test the machines

One way to help developers save time is to adopt contract driven development and testing.

Currently, this process for many developers is inefficient and time consuming. As such, this is adversely impacting release velocity. The following tasks are a heavy burden on developers, and are causing delays:

  • test planning
  • test creation
  • test maintenance
  • test automation
  • results analysis

On one hand, implementing all these tests on the component level (each endpoint, microservice) takes a lot of effort and maintenance, eventually resulting in less time for your developers to write code.

On the other hand, not implementing the tests often transfers the issues to UI testing teams, who will either not catch the problem (for example, new feature of B2B integration), or will require more debugging and troubleshooting in a later stage, which is the opposite of shortening the feedback loop paradigm.

This is why many businesses are shifting to at-scale solutions that help developers implement these tests effortlessly. These solutions, built by algorithms, can save a lot of time for developers by creating and maintaining tests.

When documentation and tests are done effortlessly, your microservices contracts can be covered and used by other teams without fear of major issues. Additional benefits include:

  • Current development will break contract (since tests will catch it)
  • Enhancements can be communicated to our consumers (internally or externally) ahead of time (staging)
  • Consumers can use the contract self-servingly by minimizing the interaction with the service owner due to the documentation

To improve software reliability at the usual pace of software development, this is why my colleagues and I think it's important to let the machines test the machines.

API traffic observability

Another way to save developers time is to minimize the time they have to spend finding the "needle" in the cloud native "haystack."

With tons of microservices, as well as multi-protocol, synchronous and asynchronous calls, it makes things hard for developers to understand. It also becomes difficult to debug and troubleshoot your code, which is where we see developers spend most of their time (when they are not coding).

We have created a simple-yet-powerful API traffic viewer for Kubernetes - called Mizu - which helps enable developers to view all API communication between microservices, message-queues, and more.

Tools like Mizu can also help efficiently debug and troubleshoot regressions. Think TCPDump and Chrome Dev Tools combined.

Additionally, this can replace the hours of time it often takes to get an environment, run scenarios over and over, change code to export log messages, and then go through these logs. This time-saver is simply done by viewing the traffic and getting validations (schema, response codes, performance, etc.) directly based on the traffic observed - ultimately helping developers and engineers pinpoint potential problems.

Mizu is available to download as an executable binary from or as source code directly from its GitHub repository.

As we use this open-source tool to improve our comprehensive microservice offerings, we have developed a full roadmap by which we may accommodate engineering requirements.

Let us know if there's anything else you'd like to see in Mizu, and we'll make sure to upgrade its roadmap based on your valued feedback.

How we hope to continue to help developers

As a microservice platform for cloud native systems that can scale across any number of services, we want to continue to help businesses in various industries. We want to contribute to the community in many ways, by helping developers do things such as:

  • Understand how services interact with each other with automatic contract discovery
  • Ensure system-wide contract adherence with tests that write themselves
  • Start to test early with test environments as code, automatically mocking all service dependencies
  • Ideation and creation of additional services for cloud native companies who use Kubernetes, Docker, Kafka, Postman, and other top platforms

When developers get this type of knowledge and assistance to understand applications and efficiently debug and troubleshoot, they are able to achieve the microservice testing workload much faster, giving them precious time back.

As your business grows, continue to consider the following question: Are you helping your developers save time?


To hear more about cloud native topics, join the Cloud Native Computing Foundation and cloud native community at KubeCon+CloudNativeCon North America 2021 - October 11-15, 2021      


Alon Girmonsky CEO and Co-Founder, UP9

Alon Girmonsky 

Alon Girmonsky is the CEO and co-founder of UP9. With an extensive background in web development, startups, entrepreneurship and investing, Girmonsky has used his decades of experience to build his presence as a business leader in the technology industry.

Published Monday, October 04, 2021 7:37 AM by David Marshall
Filed under: ,
There are no comments for this post.
To post a comment, you must be a registered user. Registration is free and easy! Sign up now!
<October 2021>