devopsy.kinsta.cloud

Tag: app testing

Perforce Applies Machine Learning to Generate Synthetic Data for App Testing

Perforce Software has added a tool that leverages artificial intelligence (AI) to make it simpler for application development teams to generate synthetic data for application testing purposes.

Mayank Ahluwalia, a senior product manager for Perforce Delphix, said Delphix Synthetic Data makes use of machine learning algorithms to generate synthetic data for specific use cases. It automatically identifies data structures, relationships, and business context across multiple sources.

Historically, DevOps teams would have had to manually provide access to those data sources using some type of legacy tool, he added.

The overall goal is to limit or eliminate the need to give application development teams access to production data in order to test an application, noted Ahluwalia. At the moment, providing those teams with access to data needed to run tests has become a bottleneck that can be eliminated by using a self-service platform for generating synthetic data, he added. That capability will be especially critical as AI agents are relied on more to create and run those tests, said Ahluwalia.

In far too many instances, the data being used to test applications is not especially useful. In fact, a recent Perforce survey finds only 34% said synthetic data provides referential integrity and only 36% said it provides data realism. Machine learning algorithms that have been trained specifically to generate synthetic data typically generate synthetic data that can be much more closely aligned with a specific use, said Ahluwalia.

DevOps teams can then more easily decide what mix of synthetic and masked data can be used to create tests that better reflect the actual environments where code will run, he added.

Delphix Synthetic Data is designed to enable both human developers and AI agents to access data via a graphical user interface, application programming interfaces (APIs) or the Model Context Protocol (MCP). DevOps teams can then also load that data into the large language model (LLM) of their choice to generate tests to better control costs, noted Ahluwalia.

It’s not clear at what pace DevOps teams are now applying AI to application testing. However, as it becomes easier to generate those tests, the overall quality of the applications being built and deployed should improve. In the meantime, however, the pace at which code is being generated in the AI era is now in many organizations overwhelming existing workflows for testing applications. More often than software engineers may care to admit, even more code that has not been properly vetted is now as a result running in production environments. As a result, it’s little wonder that the number of issues that DevOps teams are encountering after an application has been deployed in the AI era are, instead of decreasing, actually increasing.

Hopefully, there will soon come a day when the state of the art of AI testing catches up to the rate at which AI tools are being used to generate code. In the meantime, however, DevOps teams are likely to have their hands full until a complete agentic approach to managing the software development lifecycle (SDLC) is adopted.

September 30, 2026
Perforce Adds Autonomous AI Agent to Test Mobile Apps

Perforce Software today added an artificial intelligence (AI) agent that autonomously adapts tests it has created as changes are made to mobile computing applications.

Don Jackson, technical evangelist for Perforce, said via a natural language interface it’s now possible for DevOps teams to leverage an AI model that Perforce developed to generate tests using a Perfecto AI test automation platform that already eliminates the need to create test scripts.

Based on a proprietary AI model developed by Perforce Software, that approach enables the AI agent to autonomously make adjustments in real time as changes to the user interface (UI) or user flows of an application are made, he added. The Perforce AI agent makes decisions and takes actions based on the state of the artifact under test (AUT) to achieve the objective described by a tester prompt, said Jackson. It not only provides that level of autonomy to create tests, but also at execution time, he noted.

Whenever the AUT changes, as long as the objective is still achievable through user actions, the Perforce test will not break, but look to find a new way to navigate through the AUT to achieve the test objective, noted Jackson. As a result, the test case being automated doesn’t require any knowledge of a programming language, installation, selection, knowledge of, or reliance on any specific framework, and doesn’t break when the AUT changes, meaning that it requires no maintenance, he said.

The overall goal is to reduce the level of maintenance that is currently required to build and run tests that typically break each time an application is updated, he noted. In fact, it’s now possible to use an AI agent to create a test for an application before any of the code for it is ever written, said Jackson.

Finally, that approach also makes it possible to automate tests that previously could only have been conducted running manual tests, he added.

Mitch Ashley, vice president and practice lead for software lifecycle engineering at Futurum Group, said Perforce is charting a new course in AI for software testing and quality. Rather than acting as a peer programmer or tester, Perfecto AI works from the underlying requirements, such as user stories to analyze and determine the testing strategies. That approach allows it to choose the best testing tool or technique and then create the tests for that platform, he added.

In theory, AI agents should make it simpler for DevOps teams to run more tests, resulting in higher quality applications being built and deployed. However, it’s not clear how quickly DevOps teams are embracing AI. A recent Futurum Group survey, for example, finds 41% of respondents expect generative AI tools and platforms will be used to generate, review and test code. The challenge right now is determining how much to rely on AI agents to autonomously create and test code versus requiring a DevOps engineer to review output created by AI models that, depending on how well they are trained, may or may not randomly hallucinate.

July 15, 2025
Copado Streamlines Custom Salesforce App Testing

Copado today added a testing tool to its platform for managing DevOps workflows in Salesforce application environments that automatically creates scripts based on manual tests being conducted.

Announced at the TrailblazerDX conference hosted by Salesforce, Copado Explorer enables DevOps teams to integrate those scripts into testing processes that can be repeated as required.

David Brooks, senior vice president and lead evangelist for Copado, said the goal is to make it simpler for DevOps teams to add those tests to the regression tests that are incorporated into pipelines created using the Copado continuous integration/continuous delivery (CI/CD) platform.

In addition, markup and annotation tools enhance collaboration by allowing non-technical subject matter experts to provide detailed feedback and insights to quality assurance and development teams as part of an effort to streamline communications between product owners, testers and developers. Testers without a technical background can use that capability to contribute to the creation and deployment of effective automated tests. That capability makes it possible to shift testing further left to incorporate the business teams that better understand how an application should function, said Brooks.

The challenge is far too many organizations still overlook the importance of testing, noted Brooks. There is a tendency when using low-code tools to assume that not as much testing is required because the tools that generate code create a false sense of instant quality despite flaws that might not manifest themselves until an application is deployed, noted Brooks.

Rather than constantly updating applications, more testing should improve the quality of the applications being built sooner. That’s critical because most organizations don’t have the time and resources needed to continuously iterate applications until they eventually arrive at what the business requires, said Brooks.

It’s still early days so far as the level of DevOps maturity that organizations using the Salesforce platform to build and deploy custom applications have thus far attained, noted Brooks. However, just about every organization that licenses the software-as-a-service (SaaS) platform from Salesforce customizes those applications to better align them with their internal business processes, he added.

Each organization will naturally need to determine to what degree they are prepared to deploy customer applications, but it’s clear it’s becoming simpler to build them. Late last year, Copado, for example, added generative artificial intelligence (AI) tools to make it easier to manage the DevOps workflows used to build these applications, which means the speed at which these apps are built and deployed is about to exponentially increase.

Salesforce, of course, is only one of many SaaS platforms that organizations rely on to build and deploy custom applications. However, as one of the most dominant platforms, the pace at which custom applications are being built continues to increase, with a larger percentage of these applications being built by professional developers familiar with DevOps best practices.

Eventually, those DevOps workflows will be extended to every kind of developer, but for now, most organizations building applications are looking for more consistent outcomes regardless of what type of tool is used to build them.

March 6, 2024
Veracode Extends DAST Reach Left Toward Developers

Veracode this week launched a version of its automated dynamic application security testing (DAST) testing tool, dubbed DAST Essentials, that is designed to be embedded within an integrated development environment.

In addition, the company has made available a Veracode GitHub App that makes it possible to configure Veracode DAST tools to automatically scan code any time it is added to a repository.

Veracode already makes available a DAST tool that can be integrated with Veracode Fix, a tool that makes use of a large language model (LLM) curated by Veracode to apply artificial intelligence to surfacing recommendations to remediate vulnerabilities. Developers can then automatically update their source code or apply the recommended remediations as a patch using a pull request.

Brian Roche, chief product officer at Veracode, said in addition to embedding DAST capabilities into a DevSecOps workflow, DAST Essentials provides DevSecOps teams with the option to push scanning further left into integrated development environments (IDEs).

The overall goal is to automate code scanning and remediation across the entire software development life cycle. As part of that effort, Veracode will also be extending the integration of its DAST tools into additional software repositories, noted Roche.

It’s not clear whether AI will fully resolve software supply chain security concerns, but the one thing that is certain is the amount of code being generated is already starting to exceed the ability of DevSecOps teams to effectively manage. DAST Essentials provides a way to apply scanning at the front end of the application development process in the hopes that fewer issues will arise once code is merged with a build. However, given the number of issues that can arise, most organizations will also need to continuously scan builds as they are updated.

In the longer term, Veracode also plans to scan code after it’s been deployed in a production environment to enable DevSecOps teams to address zero-day vulnerabilities that are discovered after an application is deployed.

While a lot of DevSecOps progress has been made in recent years, there is still much work to be done. Developers still don’t scan code as frequently as they should, and there are still updates being made to codebases that occur outside of a DevSecOps workflow. However, as regulations for building and deploying software become more rigorous in the years ahead, it’s only a matter of time before automatically invoking code scans at multiple points of the software engineering process becomes mandatory.

In the meantime, DevSecOps teams will need to find ways to address application security issues in a way that causes the least amount of friction possible. Most developers have an appreciation for security, but far too many still view it as an obstacle to be overcome rather than a quality attribute that needs to be attained and maintained. However, those same developers will complain when cybersecurity teams discover potential vulnerabilities that a developer first must determine affect an application and then apply a patch as necessary. The challenge, as always, is finding a way to ensure application security without slowing down the pace of application development.

November 28, 2023
FAQs for Software Testing: All the Background You Need

No matter what type of application you and your team are building, testing is a critical step in the software development life cycle (SDLC) that can not be overlooked. In this article, I’ll answer frequently asked questions about software testing, why software testing matters and suggest best practices to help ensure your application is ready to delight customers by the time it is deployed.

Why Do We Need Testing?

Software testing involves evaluating an application to see if it meets the requirements and functions it was built for. The process includes identifying defects, errors and bugs, along with flaws in user experience. Software testing is so critical because finding and fixing these bugs and issues in the development process means the end product reaching customers works properly and reliably and delivers a high-quality user experience. Additionally, testing during the development process makes bugs easier and less expensive to fix as opposed to making fixes after an application has been deployed.

Overview of Testing Types

Let’s quickly define the common types of software testing:

● Unit Testing: This process evaluates individual components of software to ensure they are working properly.
● System Testing: This involves ensuring an entire application or system meets requirements and functions as it should, end to end.
● Integration Testing: This looks at whether or not different modules of an application or system work properly together.
● Regression Testing: This process revisits previously tested components of software to make sure they work correctly after a change has been made.
● Acceptance Testing: This process determines whether an application meets the needs of end users and is ready to be deployed.
● Usability Testing: This process assesses how user-friendly a customer will find the product.

Creating the Plan

Any solid software testing plan is going to incorporate multiple testing approaches, including manual, automated, user experience, exploratory and non-functional testing. You’ll start by defining the scope for what parts of your application, integrations and functionality you need to test for. Then, you can decide what type of testing methods are needed for each and document these to ensure consistency.

You’ll want to combine code coverage and test coverage to ensure the code for your application is tested thoroughly. The type of tests you prioritize will vary based on different products, and your testing strategy will certainly evolve and grow over time.

Measuring Your Strategy for Thoroughness and Effectiveness

To ensure your testing strategy is thorough and effective, you will need to make sure to test for code, device coverage and all aspects of user experience. The bottom line for the program should be delivering value to the business by making sure the application works as intended for users. To be effective, testing should take place before an application reaches end users, so issues and bugs can be identified and fixed before deployment. To be thorough, testing strategies must be balanced, end-to-end, and look at functionality, usability, accessibility and more.

Effective software testing can be measured in a few ways, including:

● Code Coverage: The percentage of code that is tested.
● Test Case Effectiveness: The percentage of test cases that found defects or bugs.
● Time to Detect and Fix Defects: The time it takes to find and fix issues in an application.
● Defect Density: The number of defects found per unit of code.

Improving Your Testing Approach

Your software testing program should be evolving and improving over time and can improve by:
● Including test-driven development
● Leveraging a shift-left approach
● Using automation where possible
● Benchmarking QA for current projects versus previous ones
● Conducting a cost-benefit analysis

Testing Best Practices

While the below list is not exhaustive, here are some top best practices to keep in mind as you build out a software testing practice at your organization:
● Incorporate the voice and feedback of your customer into product design
● Make accessibility a priority
● Test throughout the entire SDLC, including in pre-production, after changes are made to code, and in-sprint testing
● Maintain a matrix for the different devices using your application
● Prioritize high-quality user experience
● Automate repetitive tests where possible
● Review and adjust testing processes regularly, as needed
● Track and report results to analyze trends and identify areas for improvement
● Balance between leveraging different testing types

Your organization’s software testing strategy directly impacts the quality of the end application you deliver to your customers. Poor usability, accessibility, and reliability of an application can frustrate users and send them to competitors, while high-quality user experiences and application performance can boost adoption and keep customers happy and loyal to your brand. With so much competition, taking the time to build out, adjust and prioritize software testing is critical for modern businesses.

October 30, 2023
ForAllSecure Streamlines Application Security Testing

ForAllSecure today provided early access to dynamic software bill of materials (SBOM) generation and software composition analysis (SCA) validation capabilities within its Mayhem Security automated code and application programming interface (API) testing tool.

Josh Thorngren, vice president of product at ForAllSecure, said the dynamically created SBOM lists only the components present at runtime. That’s a critical capability because, given the rate at which most code is developed today, most SBOMs are out of date shortly after they have been created, he noted.

In addition, Mayhem Security will also now filter results from SCA, static application security testing (SAST) and other similar tools to only surface vulnerabilities that are actually present in the code at runtime.

That approach will substantially reduce the cognitive load that developers experience today when reviewing the results these tools would otherwise generate when applied to the entire code base, said Thorngren.

There’s been an ongoing effort to shift more responsibility for application security left toward developers. The challenge is many of the security tools being provided to developers present an overwhelming number of alerts that, upon investigation, don’t impact code actually running in a production environment, noted Thorngren.

As a result, developers become less inclined to run these tools and miss the chance to discover vulnerabilities earlier in the application development life cycle, he added.

Discovering those vulnerabilities is becoming a more pressing issue as more developers employ generative artificial intelligence (AI) platforms trained using general-purpose large language models (LLMs). While those platforms make developers more productive, they also generate code snippets that have the same vulnerabilities as the code that was used to train them. The result can be an even greater number of vulnerabilities finding their way into production environments than there already are.

At the same time, governments around the world are debating legislation that would make organizations around the world more accountable for application security. As that legislation becomes law, it’s only a matter of time before an exploited software vulnerability results in heavier fines and penalties. It may be a while before those proposals become law, but organizations will need to start shoring up their DevSecOps practices today to address those requirements.

It’s not clear whether developers will ever fully embrace security, but identifying and remediating vulnerabilities can become a lot less painful than it is today. At a time when there is more focus than ever on developer productivity, the less time spent remediating vulnerabilities, the more time there should be to write code. In effect, organizations should be able to adopt secure-by-design principles for application development, noted Thorngren.

Ultimately, any effort to reduce the number of vulnerabilities in applications will go a long way toward bridging the current divide between cybersecurity teams that view developers’ lack of appreciation for security as the root cause of many of the issues they face. At the same time, if it becomes easier to identify and remediate vulnerabilities, fewer developers will view cybersecurity as an obstacle to be circumvented.

October 4, 2023
Tricentis Adds Device Cloud Service to Scale Mobile App Testing

Tricentis has extended its cloud service for testing applications to include the ability to emulate multiple classes of mobile computing devices.

Mav Turner, CTO for DevOps at Tricentis, said the Tricentis Device Cloud (TDC) eliminates the need for organizations to acquire multiple physical devices to test mobile applications at scale.

Capabilities include the tracking of key performance indicators (KPIs) such as blurriness, slow downloads, HTTP redirects and network or connectivity issues that adversely impact the user experience, in addition to performance issues such as load times and excessive consumption of CPU, memory and battery resources.

The grid-based service also uses machine learning algorithms to apply artificial intelligence (AI) to monitor application performance and detect video and audio quality issues.

Overall, the goal is to make it simpler for DevOps teams to build and deploy mobile applications faster and make sure they are thoroughly vetted rather than waiting for feedback from end users to discover issues that could have been easily identified before an application is deployed, said Turner.

The launch of TDC follows the company’s acquisition of Waldo, a provider of a software-as-a-service (SaaS) platform that provides IT teams with a no-code tool for generating mobile application tests. Waldo uses a virtual environment to simulate iOS and Android devices in a way that eliminates the need for physical devices to conduct tests. Instead, DevOps teams record their applications and then use the no-code tools to generate tests directly from within a browser.

In the meantime, the debate over how far application testing should be shifted left toward developers continues to rage. In theory, the more developers test applications themselves the fewer issues there should be once an application is deployed in a production environment. However, there is still going to be a need for dedicated testing teams to conduct tests across multiple stages of the application development process to ensure quality. In fact, as more routine tests are conducted by developers, it should free up application testers to focus more on edge use cases that might otherwise not be tested before being encountered by end users, noted Turner.

Testing mobile applications is more critical than ever because the cost of failure—in terms of impact on the business—is now much higher as more organizations depend on software to drive business processes. The challenge is that many of these app developers don’t have a software engineering mindset, so they need testing platforms that automatically create and run tests on their behalf in a way that can be customized for specific use cases. In time, many of those tests will be automatically created by artificial intelligence (AI) models that should reduce the cognitive load required to manage the testing process, added Turner. In effect, application testing will soon be democratized by AI, he noted.

Over time, the quality of applications should steadily improve as many of the low-level mistakes that developers make are eliminated. That should improve everything from application security to the user experience before mobile applications are initially deployed and then continuously updated.

August 7, 2023
Tricentis Acquires Waldo to Further Advance Mobile Testing

Tricentis has acquired Waldo as part of an effort to expand the scope of the automated testing capabilities it provides for mobile applications.

Waldo adds a software-as-a-service (SaaS) platform that provides IT teams with a no-code tool for generating mobile application tests. Waldo uses a virtual environment to simulate iOS and Android devices in a way that eliminates the need for physical devices to conduct tests. Instead, DevOps teams record their applications and then use the no-code tools to generate tests directly from within a browser.

Tricentis CTO Mav Turner said Tricentis opted to acquire Waldo because it makes it simpler for IT teams to generate tests that can be integrated across a DevOps workflow.

There currently is a lot of debate over how far application testing should be shifted left toward developers. In theory, the more developers test applications themselves the fewer issues there should be once an application is deployed in a production environment. However, there is still going to be a need for dedicated testing teams to conduct tests across multiple stages of the application development process to ensure quality, noted Turner.

The difference is more of those tests can include edge use cases that previously there would not have been enough time to conduct, he added.

Earlier this year, Tricentis added the ability to test native iOS and Android applications to its Testim software-as-a-service (SaaS) platform as part of an effort to extend the reach of that platform to applications that run natively on a mobile device.

Testing mobile applications is more critical than ever because the cost of failure—in terms of impact on the business—is now much higher as more organizations depend on software to drive business processes. The challenge is that many of these app developers don’t have a software engineering mindset, so they need testing platforms that automatically create and run tests on their behalf in a way that can be customized for specific use cases.

Over time, the quality of applications should steadily improve as many of the low-level mistakes that developers make are eliminated. That should improve everything from application security to the user experience as applications are continuously updated.

In addition, organizations that embed testing within DevOps workflows are steadily reducing the number of issues that need to be addressed before applications are deployed.

Hopefully, as more artificial intelligence (AI) is applied to the testing process, the number of reasons tests are not run as frequently as they should be will steadily decline. Today, it is still too difficult for many developers to author tests, so they don’t conduct as many as they should. Of course, many of them also simply run out of time when writing the code that drives the application takes longer than anticipated.

One way or another, developers will run out of excuses for not running tests as accountability for code quality increases.

July 11, 2023
Developer’s Guide to Fuzz Testing
Fuzz testing continues to grow in popularity among developers within the open source community. Google’s open source security (OSS) team recently reported finding more than 40,000 bugs in 650 open source projects through the use of fuzz testing. But if you have no clue what fuzz testing is (yet), don’t worry. You’ve come to the right place.

What is Fuzz Testing?

Fuzz testing is a dynamic testing method for finding bugs and security issues in software. During a fuzz test, a program or a function under test gets executed with invalid, unexpected or random inputs to uncover unlikely or unexpected edge cases.

Value of Fuzzing for DevSecOps

As we know, DevSecOps extends the approaches of DevOps and Agile by adding suitable security testing methods alongside every phase of the software development life cycle (SDLC), creating a dynamic and continuous testing process.

Part of that testing process can and should involve fuzzing to detect security and stability issues at all phases of the SDLC and empower developers to ship software quickly and securely. For example, to prevent regressions from going live by running automated fuzz tests on every code change.

Especially in the automotive industry and complex embedded projects, where a lot of untrusted and complicated data gets processed, fuzzing brings excellent benefits to DevSecOps. Indeed, developers can apply fuzzing similar to unit testing to automatically test their security-critical modules for potential vulnerabilities. But with fuzzing on an integration level, they can also cover all the complicated and dangerous edge cases that can occur in the interaction between different modules.

Fuzz Testing Benefits

Fuzzing code generates thousands of automated test cases in a second, with the fuzzer receiving in-depth feedback on code coverage and the program states reached to simulate the interaction of different modules during the execution of the source code. The fuzzer can adapt and mute its inputs based on runtime feedback in the following iterations to maximize code coverage. Some of the benefits are:
1. (Almost) no false positives: If you find a crash, fuzzing provides you with the error source and the malicious input that caused the issue. So, you can be sure that each finding is a real vulnerability.
2. Debug reproducible findings: Modern fuzz testing tools will provide you with the input causing the issue, including the source of the error. With this, you already have a lot of helpful information to reproduce the bug and load it directly into the debugger.
3. Find issues in forgotten edge cases: Because fuzzing is executing a program with invalid or random input, it also uncovers unlikely and unexpected edge case errors that would not otherwise have been revealed.
Who Uses Fuzz Testing?

As cybersecurity regulations and standards continue to expand globally, more and more organizations are extending cybersecurity programs and running automated security testing before they ship software. Whole industries, especially those that involve advanced quality and security regulations, are setting standards for security testing that recommend fuzz testing, including automotive, aviation, finance, healthcare, telco and energy.

Digging deeper into the automotive industry, for example, a variety of International Organization for Standardization (ISO) and other organizational standards now recommend fuzzing:
Best Practices

The most effective way to do security testing, fuzzing included, is to do so continuously. This means integrating fuzzing right into your CI/CD pipeline. Doing so creates quick feedback cycles so developers can fix security vulnerabilities before the code is shipped. Integrating fuzzing tools into code hosting systems like GitHub is also valuable. Doing so allows communication and alerts to be shared across your DevOps team as soon as a problem is uncovered, which helps to facilitate fixing vulnerabilities.

What Bugs Can I Find?

While the practice remains relatively new, fuzzing has already discovered thousands of bugs across different use cases. Bug and vulnerability types discovered include:
- Remote code executions
- Injections, which can be triggered by untrusted inputs
- Memory leaks: Incorrect memory allocation
- Exposure of sensitive data: Accidental exposure of personal data
- Functional bugs: Inputs that are not being responded to
and many more bugs, such as undefined behavior, uncaught exceptions and buffer overflow. Learn more.

Getting Started

You can try out an open source fuzzer, like Jazzer (for Java testing) or the CI Fuzz CLI (for C/C++ testing). When you’re comfortable with fuzzing and want to use this approach in more complex environments, enterprise solutions offer added features like API fuzzing, reporting and CI/CD integration.

So give it a shot and join the community of open source developers using fuzzing to quickly and securely ship their software.
November 8, 2022
Continuous Delivery Advances Come at Cost of Testing

A survey of 820 application development professionals conducted by Applitools, a provider of an application testing platform, found well over a third of respondents (38%) working for organizations that now deploy daily changes to production environments.

The challenge is that application testing is not able to keep pace with that rate of continuous deployment (CD). The survey found organizations are seeing test suites covering less than 50% of applications.

Applitools COO Moshe Milman said a major reason test coverage is so low is that more than 40% of respondents said their continuous integration (CI) test suites can take more than an hour to run, which often resulted in tests either being postponed or possibly not run at all, he noted.

Most organizations are also still relying on manual testing processes that can’t keep pace with the accelerated rate of application deployment and subsequent updates, added Milman. More than half of organizations (55%) automated less than half of their testing, according to the survey. More than two-thirds of respondents (67%) are embracing test automation to improve their test coverage, the survey found.

In general, the percentage of organizations that are now employing CD processes to accelerate the pace at which applications are deployed is steadily increasing, said Milman. Manual testing processes, however, slow down the rate at which organizations deploy code. Many organizations routinely make trade-offs between application quality and a need to deploy code faster. Inevitably, there will be issues that can be traced back to decisions to not adequately test code prior to deployment, noted Milman.

Overall, the survey found 90% of respondents building and deploying web applications, followed by 52% that were building and deploying mobile applications. Only 30% are building desktop applications. Testing of the applications, however, tends to vary widely. Nearly two-thirds of respondents (65%) said they tested applications on an end-to-end basis, with 55% testing integration followed by unit testing (53%) and application programming interface (API) testing (51%).

However, only 26% tested application performance, followed by 13% that tested security and 12% that tested load, the survey found.

Part of the issue, of course, is that it’s not always clear who is responsible for application testing. In theory, developers are accepting more responsibility for application testing as they take more responsibility for managing applications on an end-to-end basis. In practice, developers are often rushing to make application development deadlines. It’s not uncommon for developers to skip or limit testing in the name of productivity. Many of them have also embraced agile development methodologies that, at least theoretically, allow them to address any issues that might arise via the next application update.

The issue that arises is that end users have become less tolerant of experimentation. If an application doesn’t initially work as expected, it’s exceedingly difficult to regain user confidence. Many will simply evaluate another similar application. The irony, of course, is that in the race to deliver code faster, application experience winds up being sacrificed because of the lack of time to properly test an application before deploying it.

July 29, 2022