Shorten the SDLC With DevTestOps in Agile | Why Teams Do It
Tags: devops, testops, devtestops, agile
Published: 2021-09-14 03:53:57

---
title: Shorten the SDLC With DevTestOps in Agile | Why Teams Do It
published: true
date: 2021-09-13 03:19:31 UTC
tags: DevOps, TestOps, DevTestOps, Agile
canonical_url: https://www.katalon.com/resources-center/blog/devtestops-agile-sdlc/
---
>**Due date: 23:59 p.m Oct 25th, 2021**
>**The State of Quality Report 2021**
>_Wouldn’t it be great to know how peers and experts are staying ahead of their quality assurance game? That’s why we're creating The State of Quality Report 2021 to collect the best QA practices from you, professionals of all levels.
We are happy to offer **the first 100 respondents a $30 Amazon gift card**, along with the final report from the survey results. [Raise your voice!](https://www.research.net/r/medium-devto)_

## ![Shorten The SDLC with DevTestOps in Agile | Why Teams Do It](https://d1h3p5fzmizjvp.cloudfront.net/wp-content/uploads/2021/09/banner1.png)

## **DevTestOps and DevOps – Not Just Another Hype**

Don’t worry. DevTestOps isn’t another new term to create turbulence in our IT and DevOps world. 

Similar to other topologies like DevSecOps, which emphasizes more on the “Sec,” or security matters, DevTestOps stresses the aspect of continuous testing and CI/CD in DevOps. 

At the same time, to uphold the culture of saying “no” to working in silos, the DevTest approach specifically aims to end the lasting bad blood between the development and testing teams. 

## **The QA and Dev Conflict Before DevTestOps**

![QA engineers vs Developers](https://d1h3p5fzmizjvp.cloudfront.net/wp-content/uploads/2021/09/The-QA-and-Dev-Beef1.png)

“Testers and developers are the best of friends,” said no one ever.

When DevTestOps was still an unfamiliar term, this disconnection was sadly formed from the contrasting technical expertise and objectives that each party holds: developers build the software and testers search for risks to verify that everything works. 

And this just brings them back to the same old loop: developers spending hours on end writing the code, QA engineers dreading over the tickets of bugs they have to log and both seeing each other as human-form punching bags when it repeats. 

Moreover, the duty of code quality can slowly be forgotten in the developers’ minds as they know their work would be tested either way. 

It seems like there isn’t a way out of this conundrum – and letting developers _entirely_ test their own code is not an option. 

### **Inattentional blindness and cognitive biases**

There’s something called [_inattentional blindness_](https://en.wikipedia.org/wiki/Inattentional_blindness), or author bias, a symptom that causes a creator to overlook the faults in their own piece of work. 

Over the course of developing code, developers build a certain familiarity or cognitive bias with their work, leading them to perform revisions with the expectation that everything already works as they have planned. 

What they really need are testers to act as a pair of fresh eyes and use the software or application with a testing mindset. Unfortunately, this pops up a different issue for the testers’ side – _independent testing._ 

With the type of expertise that testers hold, ranging from technical perspectives to cognitive biases, the typical flow leaves QA engineers to be involved only after the development team has finished coding. 

### **The lesson to learn from NASA’s Mars Climate Orbiter (MCO)**

![NASA’s Mars Climate Orbiter (MCO)](https://d1h3p5fzmizjvp.cloudfront.net/wp-content/uploads/2021/09/The-lesson-to-learn-from-NASA%E2%80%99s-Mars-Climate-Orbiter-MCO.png)

You might have heard of the 1998 [NASA Mars Climate Orbiter](https://www.simscale.com/blog/2017/12/nasa-mars-climate-orbiter-metric/) (MCO) incident. A year after its launch in 1998 to become a weather satellite and better learn about Mars, the MCO lost its signal to ground control. Lost in space, the team was able to determine that the cause of the failure was due to miscommunication about the units of measurements used by the engineers in the navigation team and the designer of the spacecraft.

With one function calculating everything in millimeters and meters, and another in inches, feet, and pounds, the lack of collaboration between the two teams from the start led to the project going all to waste. 

If they had worked more closely together and agreed on the metric system to be used in the pre-development phases, perhaps humans would’ve had the chance to know if Mars was habitable and aliens existed.

In the software development world, testers should not be left out on activities such as:

- Stakeholder or client meetings 
- Process of drafting the user story 
- Functional or non-functional requirement specifications 
- Division of tasks and enhancements 

## **Benefits of The DevTestOps Approach **

### **Faster delivery cycle and reduce bug escapes **

Popular platforms such as GitHub or Jenkins now act as an additional safety net before delivering builds to testing teams. Whenever a commit is made to the central repository, automated regression, unit and integration tests are instantly triggered.

In terms of collaboration within the development department, CI tools decrease the likelihood of merge conflicts (a.k.a merge hell) and integration defects.

The weight of worrying about damaging bugs left undiscovered until later stages can now be taken off QA’s shoulders. Given that the majority of regression issues are spotted beforehand, testers are able to further expand test coverage with exploratory testing of the software with countless scenarios. 

### **Help teams craft the right automation toolchain **

Interoperability and adaptability are key when building the right toolsets for your team – both in DevOps and DevTestOps.  

Open-source solutions might be free with self-taught materials online, but chances are they would require a high level of programming expertise. This is ideal if your team has a large number of experienced programmers to code everything from scratch and has the effort to maintain the framework and workarounds to integrate with [CI/CD](https://www.katalon.com/resources-center/blog/ci-cd-introduction/). 

As for commercial tools, despite having to increase your spending on licenses, offer teams ready-to-use software, access to devoted customer support for members at all levels to quickly onboard and productivity-centric functionalities for larger-scale projects.

Here are a couple of popular tools for different types of testing needs:

- **Unit testing frameworks:** xUnit, Jest, Mocha
- **Static code analysis:** SonarQube, ReSharper
- **API testing:** Postman, SoapUI, Swagger
- **End-to-end testing:** Katalon Studio, Selenium
- **Test reporting:** Katalon TestOps, Allure, ReportPortal

## **Best DevTestOps Testing Practices for Agile Teams**

Going Agile has been the [go-to strategy](https://www.katalon.com/resources-center/blog/devops-testing-strategy/) for modern testing teams. Whether a startup firm or a world-renowned organization, optimizing time-to-market and ensuring customer satisfaction are where the lines always cross. 

### **Microservices and CI/CD**

Following a microservices-based architecture offers an opportunity to entangle the struggle of trying to manage an application or software as a whole. 

By keeping services loosely coupled and split into manageable workloads, changes and iterations can easily be made without pushing back deployment schedules. 

A single Git repo in CI is broken down into smaller builds, making automated tests lighter and faster in generating feedback to developers. The result? More production-ready code.

On the other hand, due to the incremental number of pipelines and interdependencies, the microservices journey poses challenges with the complexities in the management and testing process; integration testing and suite-level acceptance testing are said to be the most prominent. 

This once again calls for QA teams to monitor and understand the architecture from its root to maximize the coverage of test cases and identify the core causes of any arising issues.

### **How testers and developers apply DevTestOps with Katalon**

Testers shouldn’t work like security scanners at the mall – only beeping when an unpaid item passes by without concern about the rest of their surroundings. 

The minute developers put their hands on and begin the programming process, they need to know that bugs have already been created. Aside from the must-have CI automated unit and integration tests, or static code analysis, developers need to be able to quick-check the key functionalities using test automation tools. 

With the scripting and low-code features of Katalon Studio, developers can choose the Record & Playback option to generate automated smoke tests with minimal effort, and run them against the build before letting it enter the QA environment. [Learn more](https://docs.katalon.com/katalon-studio/videos/create_test_case_record_playback.html)

**Some other highlights in Studio are:**

- Quicker test creation with built-in keywords and pre-defined templates
- Page-object model and BDD design support
- [Smart test failure troubleshooting](https://www.katalon.com/smart-troubleshooting/), time capsule, [self-healing](https://www.katalon.com/resources-center/blog/self-healing-object-locator/), and test failure retry
- Simple [Selenium project migration](https://www.katalon.com/resources-center/blog/migrate-selenium-katalon/)

On the testers’ side, you can pass down the common mistakes that developers often encounter, and offer automated tests with reusable workflows for developers to run end-to-end tests. It really is a win-win situation for both teams without adding any major changes to the working process. 

Can you see the friendship forming here? Your conversations will move from work, like helping you understand more the internal logic of their code to come up with corner and edge cases, to pointing out user story and regression risks.

But to centralize _all_ of your DevOps testing activities, TestOps is a [**test orchestration platform**](https://www.katalon.com/resources-center/blog/test-orchestration-quality-analytics/) that connects all of your ecosystem compartments together and makes collaboration much easier. It offers:

- Native CI integrations with Jenkins, Azure DevOps, CircleCI
- Advanced reports to understand Studio test failure ASAP
- Historical data to identify trends in execution time, flakiness rate, and staleness 
- Jira and Slack integration to stay posted on all tickets and tasks

Now you know. It’s not impossible to make these two departments work well together. Just get the right mindset, skills and toolsets for us to all live in harmony again.

[![DevTestOps with Katalon](https://d1h3p5fzmizjvp.cloudfront.net/wp-content/uploads/2021/09/Button-_DevTestOps-with-Katalon.png)](https://www.katalon.com/devtestops/?utm_source=katalon&utm_medium=blog_cta&utm_campaign=devtestops_agile)

The post **[Shorten the SDLC With DevTestOps in Agile | Why Teams Do It](https://www.katalon.com/resources-center/blog/devtestops-agile-sdlc/)** appeared first on **[Katalon Solution's Blog](https://www.katalon.com/resources-center/blog/.)**.