Back to blog results

May 9, 2019By Jacek Migdał

Software visibility is the key to innovation

Software is eating the world. How we spend time, what we eat, who we meet, how we communicate, where we travel... is defined by the code. Increasingly, software is calling the shots and telling humans what to do. With deep learning, this trend is just going to accelerate.

The most powerful companies that used to rule the world with professional, skilled executives are becoming incumbents getting disrupted. They are not fearing their legacy competitors, but instead a few ambitious people in t-shirts creating a startup. The founders typically have a disadvantage on most things, except one. They breathe software and build their company around it.

We are living in a golden age for software engineers. What used to take months, now only takes a few lines of integration code (e.g. processing payments). For every problem -- even those deemed impossible -- there is a SaaS tool solving it (e.g. recognizing birds in the image).

On one hand, thanks to pre-made components, it has never been easier to build, automate and solve problems. Nearly all the software running your company was not written by engineers within the company. A huge part of your stack might be run by someone or somewhere else (e.g. cloud functions, APIs). Moreover, there is a proliferation of open-source software, package managers (maven, npm, etc) and container images.


On the other hand, interactions have never been this complex, across many companies, servers, and services. For example, an average single page visit to European news site can trigger interactions with 40 companies. Finding the root cause of simple issues can easily turn into a multi-hour debugging session due to the complexity of integrations.

Software interactions are like gamma radiation. Extremely powerful, but invisible to the human eye. Mysterious to people outside of the specialized profession. Hard to reason about, invisible without proper instruments.

Bugs in software have mortal consequences (example 1, 2 and 3), financially ruined companies and individuals (example: $440 mln in 30 minutes), caused massive data breaches (example) and caused countless other forms of destruction. None of these problems were intentional, but usually the result of a lack of understanding of complex interactions.

Logs and metrics are keys to understanding and managing modern software. They universally explain events as well as key characteristics. They allow monitoring and troubleshooting. Having them all in one place gives operators a holistic view. That allows to ask interactive ad-hoc questions and get quick answers. That capability speeds up troubleshooting sessions because you can view, reason about and analyze the interactions. You can also codify your learnings and set up monitoring to detect recurring problems. Monitoring automates pro-active visibility of future issues.

Logs and metrics are like human senses: seeing and hearing. One can function without those senses. Opening your ears opens a world of metrics awareness. Opening your eyes gives you visibility of logs. You can analyze the ROI (return on investment) all day long, but the 10+ times improvement in what you can accomplish is a game changer.

This is what we do at Sumo Logic. We make a crucial tool for software visibility. Our customers have used us for challenges such as:

  1. Monitoring sensors during the medical trial.
  2. Investigating a murder case in a rented apartment.
  3. Uncovering root cause of multi-million data breach and preventing others from occurring
  4. Making sure your video streams works smoothly during major events.
  5. Debugging Internet of Things devices.

Complete visibility for DevSecOps

Reduce downtime and move from reactive to proactive monitoring.

Jacek Migdał

More posts by Jacek Migdał.

People who read this also enjoyed