DevOps is no longer a new concept. Companies have embraced the term. However, it may appear that some are not achieving the ultimate goal that DevOps aims to achieve. Let’s dive into why that could be.
The ultimate goal is to see continuous flow of value in the production environment, enabling IT to move at the speed of business. Organizations that embrace DevOps principles, such as the development of pipelines, code promotion tools, and even infrastructure-as-code (IaC) techniques, can build the foundation for continuous integration and deployment (CI|CD). While the principles of DevOps are rock-solid, some potential challenges come with embracing this approach.
As more companies leverage Agile-at-scale methodologies, developers spend time building pipelines and managing the process of CI|CD. While many developers find this work stimulating, it detracts from their primary focus, which is to create features that result in value to the consumer. Companies must focus on building the infrastructure and teams necessary to manage the DevOps foundation, thus freeing developers to focus on value enablement.
How can QA make life easier for developers?
Another challenge with DevOps is the concept of continuous testing (CT) or continuous quality (CQ). As the pipeline becomes automated, the testing must also be automated to ensure that testing doesn’t become a bottleneck to the continuous flow of value. Suppose the developers can get automated builds to happen. In that case, test automation needs to be in place that verifies the viability of the build and then executes automated testing that verifies the core functionality still works. If either fails, the build needs to roll back automatically, and the results provided to the development team with enough detail to help them zero in on the issues. This puts testing directly into the hands of the developers as the suites automatically run on deployment and environment promotions.
The role of quality assurance (QA) in a continuous flow environment is to build automation into the pipeline process seamlessly. Too many organizations implement DevOps but still rely on testers to manually kick off test cases (manual and automated) once the build is deployed into an environment. This injects wait points and waste into the processes, making achieving high flow rates more challenging for the team.
How do we best-fit testing tools into the pipeline?
The key to testing in the pipeline is identifying the best tools for the purpose. With the development of modern microservices, well-defined provider and consumer contracts must be established.
These contracts will establish the criteria for testing both how the microservice will behave and how other parts of the application will consume the outputs of the microservice. Good contracts also define the service levels for the microservices, enabling the testing team to verify the performance of each microservice call. Tools like Tosca can provide insights into your microservice performance and quality. These tests can be integrated into the pipeline and work well with code analysis tools that verify the code on check-in.
As the application is integrated, tools like Testim can be leveraged to verify the software is doing everything it is supposed to and nothing it is not. The beauty of the tool is that it leverages artificial intelligence (AI) to identify changes in the application that would impact the test case and applies self-healing to fix problems the changes would have caused. This improved reliability of the test cases keeps the continuous automation working and supports continuous flow.
How can developers get faster feedback?
The secret to faster developer feedback is continuous testing built into the pipeline. As developers create their pull requests, code scan, and analysis tools look for security and quality issues within the code to ensure quality in the code branch. As the build is created, automated tests verify the viability of the compiled code and the correctness of the build. As the build is deployed, automated tests ensure the package functions correctly in the environment with smoke tests and functional verification. If any automated quality checks fail, the build or deployment rolls back, and the developer receives automated feedback on the failure mechanism. The test cases must be designed to provide specific feedback on the failure so the developers have good insights into the issues.
Accurate and concise information enables the development team to make rapid fixes and keep the code moving forward. Preventing developer feedback overload. One of the more significant challenges for development is to weed through the failure data to find the real root of the problems. Fragile test cases exacerbate this. When test cases are not robust and testers don’t implement self-healing capabilities, the result is large volumes of failures during an execution cycle. In continuous testing environments, these failures cause the deployment or build to roll back and unnecessarily overload the developers with false failures.
Leveraging AI to implement self-healing improves the resiliency and robustness of test cases and results in fewer false failures. A side effect of self-healing is increased confidence in the test automation team by the feature teams. When developers don’t have to troubleshoot the testing team’s test case quality issues, they can focus more on developing value for end users.
How does this play into Platform Engineering?
The term “platform engineering” is a newer concept for most organizations. It can be seen as the architectural backbone that includes DevOps, SecOps, PerfOps, QualityOps, and InfraOps. Simply put, the backbone enables developers to build and deploy software efficiently with minimal friction. If you are familiar with the concept of a Release Train in scaled agile (SAFe), you will know it is a set of feature teams developing value through program increments.
You can look at platform engineering as the rails on which that release train runs. It is the architectural foundation of DevOps, including CI|CD, CT, continuous security, and IaC that developers leverage to develop and deploy software consistently and faster. Leveraging AI in testing enables the test engineers to build the testing into the pipeline and enable that speed.
It’s about “Speed to Value”
Artificial intelligence in testing helps organizations move away from tested-in-quality toward a built-in-quality approach. Adding test automation into the pipeline removes waste, wait times, and friction. It enables developers to get meaningful feedback quickly on their software and enables speed-to-value.
If you are still waiting for deployments to manually kick off a set of manual or automated tests, then it may be time for you to explore how continuous testing leveraging AI can enable your testing function. Tell us about your experience leveraging AI to improve testing outcomes. It would be great to hear your feedback and address any questions you might have.
