A Message from Lightrun’s Founders
Ever since the publication of the “Manifesto for Agile Software Development” approximately two decades ago, software development has become more and more agile. Companies all over the globe have adapted new work processes, built new R&D team structures and incorporated new developer tools and methods. Agility has become the “right” way to do R&D, and organizations are willing to spend a lot of resources to become agile and improve their product delivery and customer experience.
Software development agility is the flexible management and execution of the development process. However, being the vague term that it is, usually companies relate “agility” to CI/CD. While the two are connected – CI/CD is part of agility – CI/CD does not encompass the full breadth of agility and what it offers R&D departments.
CI/CD means rapid code change, fast delivery and quality. It is a set of principles that enables pushing smaller code changes more frequently, to enable quick advancement of the product and fast error resolution. CI/CD takes place by automating building, testing and deployment, with dedicated tools like Jenkins, CircleCI, and Atlassian Bamboo. Teams also change their structure, since they break monolith development to microservices. So from larger teams built according to development specialty (e.g – backend) they turn into smaller, mission-focused and feature-focused teams.
But there’s more to agility than CI/CD. What happens after deployment, when the service is running?
Agility for Live Running Services
In recent years, the gap between development and production environments has widened. Microservices, Kubernetes, Docker Swarm, ECS, Big Data workers and serverless require complex maintenance in production. These architectures have made production issues hard to anticipate in development and even harder to reproduce there.
Simulating production data in a dev environment, as well as the scale and the user data, is on the verge of impossible. As if that’s not enough, bugs are difficult to reproduce in staging and development. To top it all off – modern architectures (microservices / serverless) have a tendency to fail more often – as is common for distributed applications.
Yet, in today’s world – the only way to understand your application’s behaviour is based on log lines and metrics that were defined during the development stage, way before production. We know how frustrating and disheartening it is to discover you’re missing a log line, just where you need it. Developers find themselves going through numerous iterative processes just for adding another log line or metric.
Engineering teams have advanced tools to analyze production, like logging tools and APMs. But each time they need new visibility into their code, they have to go through the development and full release cycle process again (and again) and recreate the preconditions for the issue. This has created the observability gap.
The observability gap limits R&D’s ability to react fast and troubleshoot production issues. Which, in turn, obstructs agility in live applications and when delivering software. In other words, the observability gap restricts developer and DevOps capability to deliver. MTTR rises, site reliability declines, and so much time is wasted.
We needed a solution for bridging this observability gap. That’s why we came up with Lightrun.
Bridging the Observability Gap with Continuous Debugging and Continuous Observability
We started Lightrun to enable development agility for solving problems in live environments. Developers have a lot of power and agility in development environments. They have debuggers, profilers, and entire pipelines. But in the most vital environment, the meat-and-potatoes of R&D departments, the environment that serves the customers, the process is still stuck and iterative, and requires a lot of time, effort and resources.
Lightrun is the first complete Continuous Debugging and Continuous Observability platform. This means the ability to add and instrument the three pillars of observability in staging or production environments, i.e while the service is live. Lightrun enables developers to securely add log lines, performance metrics and traces to production, on-demand and while the app is running. True agility and 100% code-level observability are now achieved!
Based on the same principles as CI/CD, Continuous Debugging and Observability (CDB/CO) powers development teams to shorten iterations and boost product quality and reliability. Just like CI/CD shortens the release cycle, CDB/CO shortens the RCA (Root Cause Analysis) cycle.
We also wanted to make sure that agility was at the heart of our processes, so it was important to us to incorporate ourselves into existing developer workflows, end-to-end. We started in the development environment, by integrating into developers’ existing IDEs, and ended in production, with their APM and log aggregation tools.
Lightrun was established a year ago with the vision of leading the CDB/CO revolution. Lightrun was founded by developers for developers. We both have a heavy technical background from the elite 8200 IDF unit, public enterprise companies and successful startups that were acquired. Our goal is to deeply transform developers’ lives all over the world, by disrupting the way they collect data from live apps and the way they debug and troubleshoot live applications. In the past year we were able to fundraise from some of the most prominent investors who are reshaping the development ecosystem (including senior development executives in Fortune 500 companies). We built an A-player team of accomplished members in the enterprise-level developer tool sphere, and – we built a product that already serves satisfied customers who are expanding their use on a daily basis. It is now time to launch our product and company to the public. Lightrun is emerging from stealth to become the market leader in the Continuous Debugging and Observability revolution. Contact us to learn more.