Coding, deployment, monitoring, staging; everything within the software development lifecycle should be performance-oriented. If not, one of them quickly becomes a weak link and will negatively impact the rest.
Maintaining this strict level of performance requires complete visibility, which means monitoring every stage and aligning stakeholders with the performance engineering strategy.
In this article, we explore some of the practical steps that have helped us improve our own performance visibility, sharing some valuable advice from the perspective of a nearshore software development outsourcing company.
First, it's vital to introduce the concept of performance as early as possible as this allows for discussions in which stakeholders understand that the type of information we are going to provide through performance activities is useful and relevant. This helps to dispel misconceptions and set the project up for success.
Second, performance visibility helps to improve the monitoring process by highlighting which tools will be necessary to track and monitor and keeping track of the application or platform as it moves to production. If no one is aware of what's going on, what tools are being used or what's being monitored, they can't ensure proper performance of the application or benefit from the results.
Because performance visibility is about understanding the performance status of your application, the first thing to implement is continuous performance testing, which helps collect KPIs that are useful for expanding performance visibility. A few examples of this include the maximum amount of transactions the app can handle, average response time, error rate, maximum concurrency, or the percentage of CPU required to complete certain tasks.
When choosing which metrics to focus on, it's important to look at the business requirements and goals. For example, if the goal is to reduce app load times for 5,000 users, engineers can focus on relevant metrics like time to interactive (TTI) to boost performance in this area. In fact, business requirements and customer expectations should guide the entire process.
However, don't think that you always have to start with this information or even have a clear understanding of it. More often than not, we enter into engagements with clients that don't have any of these metrics, for instance, their application isn't in production yet so they can't provide insights into how it operates.
The good news is that the best thing to do is to get started, pick a few metrics or outcomes and test for those. At the bare minimum, this gives you a valuable starting point. In fact, if you start with just a few tests, you can already present really useful information, including insights like:
Overall, performance tests produce a huge amount of raw data that can be leveraged for enhanced visibility when analyzed correctly. The future of performance involves looking at ways to implement data analysis and data science techniques into these processes, increasing visibility even further. At PSL, we're already seeing the benefits of this approach.
When acquiring metrics for increased visibility, it's important to automate as much of the performance testing process as possible.
For example, in order to check whether the application meets a non-functional requirement, load testing tools like WebLoad or LoadRunner can be used to simulate the application's behavior in a production environment. This can generate repeatable results and allow the collection of both performance testing and resource utilization metrics.
These results are then processed and sent to an elastic search database to create a historical record of the application's performance. Postmortem tools like Jupyter Notebook can then be used to analyze this data.
The QA and testing teams are also guided by non-functional requirements, so they must put customer expectations top-of-mind. If they notice that the app is loading more slowly than expected, for example, this should prompt them to raise a red flag and provide that feedback to the developers. One way in which teams can raise red flags is to implement dashboards and automated alerts.
With dashboards and automated alerts, it's important to keep in mind that these need to be dynamic and not static. Based on the fast nature of performance and performance testing, static reports are quickly out of date. They also run the risk of not including components of the process for certain stakeholders, consequently reducing rather than increasing performance visibility.
At PSL, we provide developers and customers with meaningful dashboards that show the current performance status of an application, how many APIs we are testing, how many tests we have executed, and more, depending on the client. We also implement automated alerting mechanisms that give early feedback to developers, enabling them to take action on any degraded functionality.
Once the application is deployed, the operations team will be more focused on monitoring resource utilization, such as how much memory or CPU is in use. Their objective will be to reduce costs by lowering the amount of resource usage. This is guided by target KPIs and performance dashboards, much like those the developers and customers utilize.
Ultimately, with these tools, we are able to keep performance visibility dynamic and comprehensive for most stakeholders, especially when we build dashboards for particular stakeholders or allow them to view specialized information.
Keep in mind that you need to adjust the way you present results according to the stakeholders, all of them will have different questions and necessities, some examples include the following:
No matter how technical or complicated things might get, everybody must be driven by one goal: to meet or exceed the business requirements and customer expectations. By enhancing and maintaining visibility throughout the entire software development lifecycle, stakeholders will naturally become more aligned with those goals.
In most cases, companies might not have clear expectations or performance requirements outlined, so creating the initial baseline can be a challenge. In the worst-case scenario, software development companies will need to figure out what the expectations could be from incomplete data. Eliciting information from customers about non-functional requirements can sometimes take a few weeks, after which time it becomes a continuous, live process of adjusting, defining, and eliminating expectations where appropriate.
However long this process takes, it is absolutely essential for forging and maintaining performance visibility. Business goals and customer expectations are the only way to define the performance metrics worth monitoring, so bypassing this step would be extremely counterproductive.
For DevOps teams looking to improve their own levels of performance visibility, the takeaways here are to implement automation tools, consider the future of data science techniques in performance analysis, and above all to focus on business requirements. Only then will performance visibility have any meaningful impact.
Ready to improve your performance visibility? Schedule a call with the PSL performance engineering team.