Fewer Bugs, Faster Releases: How APM Improves the Software Development Life Cycle

June 22 2018

The jobs of everyone involved in the Software Development Lifecycle (SDLC) are made easier by having application and business performance information easily available.

Breaking down a series of interdependent movements into discrete actions is often the first step to improving the performance of everything from professional orchestras to sports teams. And so it is with software.

The Software Development Life Cycle (SDLC) evolved out of an effort in the late 1960s to put formal quality processes in place in a relatively immature industry. Although the implementation of SDLC varies from organization to organization, a typical cycle includes six stages: plan, design, develop, test, release, and monitor. Decades after it was introduced, SDLC still delivers results, though there has been some confusion as to its role with the recent interest in DevOps and DevOps monitoring. Regardless of terminology, the principles remain the same. Yet solely following these principles cannot address the enormous challenge of developing applications that run on multiple platforms and in multiple geographies securely and at scale. To increase SDLC’s effectiveness for today’s enterprise development projects, organizations should consider supporting it with application performance management (APM).

APM helps developers determine whether changes are helping or hindering performance. Unified views of the application, infrastructure, and user experience eliminate guesswork while machine-learning algorithms automatically set baselines and correlate transactions within and across software tiers, stacks, and platforms, exposing dependencies and capturing errors and exceptions. Whether you are deploying an update to data centers around the world or rolling out a new containerized service in the cloud, APM makes developers’ jobs easier. Below I’ll explain how APM can lead to better results in each of the common SDLC stages.


The authors of “Solid Code: Optimizing the Software Development Life Cycle” may have put it best when they advised: “Think first, code later.” In the planning stage, product managers gather requirements and collect input from customers/end-users, salespeople, and other stakeholders. Who is using or will use the software? How will they use it? What is working and what needs to be fixed? Equally important, what resources will be needed for implementation and what is the estimated project cost? To answer these questions, developers need an accurate understanding of their current system architecture in order to surface additional requirements or identify necessary refactoring. This is where a unified monitoring solution comes in handy with automatic detection of application servers, databases, and infrastructure and the relationships between them as established by business transactions and visualized through flow maps.


Insights gained during planning support better design decisions. During design, a developer may be determining a new architecture, choosing what frameworks or libraries to use, or making algorithmic or data management decisions. APM helps developers by easily showing what systems and frameworks are in place today and how they’re being used, making it easier to decide if there’s existing code that can be repurposed or if something new needs to be created. Developers and product managers can also take advantage of the insights provided by end-user monitoring capabilities to gain an understanding of application usage patterns, user locations, browser capabilities, and any existing performance bottlenecks or failures that should be addressed in new designs.


Coders code, and for many developers this is the most rewarding life cycle stage. During the era when the waterfall approach to development prevailed, developers wrote and debugged their code and then handed it over for integration and broad testing. However, as agile methods have gained popularity, developers have gotten used to receiving feedback early and often.

By deploying APM in developer environments, developers can identify upstream and downstream dependencies based on actual code execution. They can also directly observe the impact their new code has on the larger application and address scalability concerns. As a feature takes shape, developers use APM to investigate potential issues. Will the new code contribute to network latency? How will it affect memory consumption? How does the new design perform under load? What are the proper host environment specifications? How much CPU and memory will most efficiently serve the application?

It’s not uncommon for developers with access to APM to identify and pre-empt application issues before their code reaches Testing & QA. In addition, by paying rigorous attention to scale factors, developers will minimize bugs and code changes after an application is deployed in production.


The ongoing shift to Continuous Release has increased the use of automated testing in the build pipeline—often at the cost of visibility. The result is that code containing damaging performance regressions can pass functional testing and be pushed into production. This potentially costly scenario is avoided when the test environment is monitored by APM, allowing performance metrics to be easily compared against established thresholds or prior releases. Also, as in the development environment, APM speeds up root-cause analysis of performance problems.


One of the biggest benefits APM offers to release engineers is the peace of mind of knowing that an application has been stress-tested and all existing issues have been identified in pre-production environments. Visualizations like flow maps that show what calls an application is making and heat maps that reveal performance anomalies and outliers in a microservices architecture provide additional confidence as you compare against the previous release in canary or blue-green deployments.


APM was first adopted for use in production because of the critical role it plays in reducing the mean time to resolution of performance issues. It continues to do that, but as the agility of developer teams grows, APM is also increasingly leveraged to kick off the next development cycle, providing insights into end-user behavior and the impact of application performance on business objectives. In this way, APM grounds developers in the realities of the most recent changes in the application, allowing them to make better design decisions for the next release.

While APM contributes value at every stage of the Software Development Life Cycle, adopting APM across development, testing, and production environments brings an additional reward. Giving developers and IT operations equal ability to drill down into code-level diagnostics provides the common language that is needed for a true DevOps culture to take root. DevOps is all about communication, and effective communication requires a shared perspective. APM delivers a single source of truth, eliminating finger-pointing and academic disputes over what happened, when, and why. Developers and IT operations can focus on the shared goal: the rapid delivery of high-performing, low-maintenance code.

Take a tour to see how AppDynamics APM can help your own organization throughout your SDLC!

A version of this article originally appeared in the SDTimes.

Matt Chotin
Matt Chotin is Sr. Director of Developer Initiatives at AppDynamics, charged with leading AppDynamics products to better support developers in improving performance and achieving business outcomes. Prior to AppDynamics, Matt held product leadership roles at Chegg and Adobe and co-founded his own startup.

Thank you! Your submission has been received!

Oops! Something went wrong while submitting the form