Quality Assurance Operations - make workflow smooth

Quality assurance workflows eliminate bottlenecks between development and testing. Here is how Tallyfy helps teams maintain consistent processes.

With the ever-hastening speed of technology production, software and application development need to be better and faster. From what I’ve observed working with development teams, the development aspect is not really the problem.

Developers can create with incredible speed. The real problem comes when checking and perfecting their work (i.e. testing).

The time it takes to scour through a product, explore all of the nooks and crannies, and ensure that it is 100% user-friendly, generates a bottleneck. Concepts like Agile Software Development, Continuous Integration and Continuous Development have made strides in alleviating the bottleneck, but they still haven’t completely fixed the problem.

Enter Quality Assurance Operations.

What is the big deal about Quality Assurance Operations?

The value of test implementation becomes apparent as soon as you realize what exactly it does. In the simplest terms, it integrates testing so that it is simultaneously running alongside development.

To dive a little deeper, let’s consider the major problem that Product Managers and their teams are currently struggling with: The lengthy process of developing and perfecting a product to make it market-ready. The reason this process has been made so lengthy is not, as previously mentioned, the fault of the developers. But this does not mean it is the fault of your testing team either. The fault really lies in the process.

Developers have the ability to build programs and applications remarkably quickly. But building it in minimal time does not necessarily translate into building it perfectly.

It’s rare to find a program that is 100% user-friendly and bug-free from the get-go. This means that every aspect of the application needs to be checked—and preferably by multiple sets of eyes. This checking, or testing, takes time.

Even if you have an entire testing team dedicated to testing methods like functional exploratory testing, test case execution, focused deep dive testing and regression testing, which is unlikely because of the expertise required, you’ll still find that you can’t keep up with development speed. In our conversations with operations leaders at mid-size software companies, we’ve heard the same pattern: testing backlogs grow 2-3x faster than development speed, and this gap only widens as codebases grow. And the real pain is knowing that if you could keep up with development speed, you could continuously release perfect product after perfect product.

Quality Assurance Operations allow you to do just that. As mentioned before, integrating testing processes allows you to develop, test and fix simultaneously throughout the development process.

When you’re done developing, you’re also done testing and fixing bugs. You can just release. And implementing quality assurance operations doesn’t mean hiring a bunch of new testers.

It also doesn’t mean firing your current team of testers and outsourcing all of your testings. It really just depends on your needs.

Ideally, you will have a solid testing team and you will supplement their work through outsourced testing providers.

Once you have implemented quality assurance operations, you will see benefits like the disappearance of silos between the testing and development teams; the ability to identify bugs and other problems within 48 hours, allowing developers to make the necessary changes; the scalability of testing, no matter the size of the application nor the platform used; greater confidence and less stress on product release days; and speedy and valuable program updates.

No more bottlenecks, just high quality and expedient product releases.

Calculate your QA bottleneck savings

This post discusses how testing creates bottlenecks in development cycles, with bugs identified within 48 hours through QAOps integration. Calculate how much time your team could save by running testing simultaneously with development.

Take baby steps

Human beings are not known for their adaptability or love of change. To make sure your team is on board, it can be optimal to ease into quality assurance operations. A good place to start is the incorporation of processes like Continuous Integration or Continuous Development.

Continuous Integration is essentially an automated practice where developers frequently integrate their changed or new code to the existing code repository. This helps to prevent errors and bugs that can be caused when multiple developers are working on the same program, as well as allowing developers to quickly notice and correct errors on programs they are working on alone.

There are currently many tools available that can automate this process. But it takes more than automation of code updates. Continuous Integration also requires:

1. The entire development team should be able to identify what and who caused a build break.

2. The testing team should also have access to the code repository so they can be running tests as the build is taking place. 3.

The program should be tested in a scalable clone of the production environment. 4.

Development speed should be emphasized so that any problems with integration can quickly be identified. 5. Code commits need to be run daily, if not twice or three times a day.

6. The build should be self-testing, at least for basic tests.

While Continuous Integration is by no means full quality assurance operations, it will get your team on the right track. It will create healthy practices among your developers and it will allow them to fully realize how easy and beneficial it can be to allow testing and development to be a fluid and intermingled process.

In addition to Continuous Integration, it is absolutely essential that all workflow, including quality assurance, should be consistent. You cannot choose to opt-in and opt-out when the team feels like it. The processes must be continuous, constant and regular. The most effective way of ensuring this is through a solid checklist.

The when

Always and everywhere. This means:

• Design
• Development
• Staging
• Release
• For updates, improvements or modifications to the app or software
• Specific types of testing

Where to test can also become a challenge of focus. 33% of Quality Assurance stakeholders and engineers have reported that one of the biggest challenges they face is deciding the essential areas to focus their testing. And with time constraints and tight budgets, making poor decisions in this area can be costly.

To further discuss specific types of testing in depth:

• Localization testing: Quality Assurance Operations is non-negotiable for this kind testing. When you are developing apps or software for a distinct culture or location, you need to know that it actually fits the culture. If it does not, your app will not perform. Quality Assurance Operations enable you to connect with testers in or near the culture so you can observe whether your software will connect or not.
• Regression testing: Quality Assurance Operations can help ensure that your previously developed software’s enhancement, patch or configuration change has been checked for any faults that may have been produced by the new information. For those using an agile project management process, the affordability and efficiency of Quality Assurance Operations make the nightmare of regression testing overheads disappear.

The where

The magic of quality assurance operations is its versatility. In other words, you can get testing for your application done on any device or operating system you want it available on. This is incredibly important in today’s fragmented world of operating systems:

• iOS Devices:
  • iOS 9: 84%
  • iOS 9: 11%
  • Earlier: 5%
• Android OS Devices:
  • Lollipop: 35.6%
  • KitKat: 32.5%
  • Jelly Bean: 20.1%
  • Marshmallow: 7.5%
  • Earlier: 4.3%

And you can go as big or small as you need or want—scaling up does not equate to a longer testing period.

The how

Quality assurance operations fit nicely into the workflow of software development. It doesn’t take as much of a culture change in the workplace. Based on hundreds of implementations we have observed, the shift primarily benefits developers and testers—less waiting around and more making fixes. One e-commerce company we spoke with reduced their manual QA coordination by moving from paper checklists and disconnected tools to integrated workflows with automated handoffs. The results speak for themselves. To get started, it can be helpful to implement CI so that automated tests can be regularly run, creating a complete code to be sent to testers.

Beyond implementing CI, it can also help identify any gaps that may be in your testing processes. When you can pinpoint where the bottlenecks are happening, you can address them. You can do this by:

• Finding out where your team spends the most time
• Going back through old software to find out where bugs and outages have historically been clumped

When you’ve automated a few tests, implemented CI and a checklist, and identified the weak spots in your testing, it’s time to scale up. You can only do so much testing in-house, so it is time to start moving beyond that. By outsourcing much of the manual testing, you will be able to better balance the cost, quality, and speed of development and deployment.

Track issues from report to resolution

Example Procedure

Issue Tracking

1Determine channel of reporting

2Check for duplicate/similar bugs

3Send helpful notification to client

4Create a new ticket

5Prioritize and assign

+8 more steps

View template

To help get you going, it can be a good idea to work with professionals who have experience with optimizing workflow. Tallyfy is one such organization. Their checklist app ensures the consistency you need to avoid mistakes. It will also assist you in guaranteeing that your repeatable workflows are done, done right, done on time, and done by the right people.