QA(Quality Assurance) Service by Gloify

Gloify > QA service > QA(Quality Assurance) Service by Gloify
QA(Quality Assurance) Service

The quality of a software product defines its success, you have to test an app carefully before releasing it. An experienced development team usually do a bunch of tests before final release of the app to ensure its product quality. Below we’ll discuss the process followed by the QA(Quality Assurance) service team at Gloify.

What Types of  Bugs are addressed in QA(Quality Assurance) Service?

Before we move on with the QA workflow we use for mobile and web development, it’s a good have a brief knowledge about the types of bugs.

Types of bugs

  • Blocker

This bug tends to be the most severe. Blockers don’t allow using the app’s functionality and break the business logic. The last one stands for the business rules and workflows. It describes the sequence of operations required for the app to work correctly

  • Crucial bugs

They affect the product’s functionality or data. In most cases, the business logic works incorrectly and users can continue using the application. For example, a user has an opportunity to tweet media content like images, gifs, or videos. If a user can’t tweet any images, it’s a critical bug because key business logic doesn’t work.

  • Major bugs

Such a bug leads to errors of secondary or additional features. For example, a user can’t change the profile picture. It’s a major bug since it doesn’t affect the key business logic. Visitors can use the app without a new photo. Major bugs can also mean that the feature works incorrectly .

  • Minor bugs

This defect influences insignificant functionality or non-critical data. So, the main functionality works correctly. In case of minor bugs, the feature is difficult to use or it just looks terrible.

  • Trivial bugs

Trivial bugs are less severe. Business logic works correctly but there can be some issues with user interface, misspellings, missed hover on the element, and others.

 

QA(Quality Assurance) Stages at Gloify

We at Gloify pay great attention to QA service and have been polishing related processes to deliver bug-free products to our clients. The process we’re currently using lets us eliminate possible bugs and fix them faster.

So, how do we test an application at Gloify? Let’s take a look at the step by step stage and have a brief insight about the QA process we follow.

Stages of QA process

Step 1. Requirements Analysis

The first step of any process is analysis. Our Business Analysts talk with client to understand the project requirements. After that, they create a specification sheet. This document consists of all the tools and technologies required for development and communication. Also, specification consists of project features, so QA specialists understand the tasks and requirements.

Then, Quality Assurance engineers analyze the project requirements and business goals set by the client. They try to determine logic-related issues or inaccuracies that may happen. It lets the entire team avoid major changes during software development. Also, our specialists make sure that all standards (e.g. UI/UX design guidelines, Google’s or Apple’s developer guidelines) are followed.

At the end of this stage, the client gets a detailed specification and wireframes with all the project functionality and required technologies.

Step 2. Planning

During this stage, the development team holds meetings to define testing goals and create a testing strategy.

As a result, they write a document consisting of the following information:

  • Environment. In this part, they describe all test devices, OS versions, necessary tools, and more.
  • Types of tests. They decide what types of tests are required for the project — manual, automation or both. The choice depends on the project size and requirements.
  • Checklist. Quality Assurance engineers define how to validate requirements and how much time they need for this.

If the project is large, the team can divide development into sprints. In this case, they create a testing checklist for each sprint.

This results in stage creating a detailed estimation, an accurate time required to test the app.

Step 3. Testing

After all the preparations, the team moves on with testing. QA(Quality Assurance) engineers take part in the project till release. That’s because their role here is to check the functionality developed during each sprint.

QA (Quality Assurance) engineers test both back end and front end, find bugs, and create reports for software developers to fix them. When the developer makes fixes, the QA engineer looks through code once again to ensure that it works correctly.

 

The primary task of the  QA(Quality Assurance) engineer is to validate the project requirements. It means that the app meets the users’ needs and expectations. To fulfill this task, our engineers use various tests.

Functional tests

The main task of these tests is to ensure that features work according to the business logic and comply with the project requirements.

Negative tests

This technique stands for inputting invalid data and analyzing software behavior. Negative tests show the app’s stability and error handling capabilities.

Positive tests

QA engineers perform positive tests by adding valid data. Such tests allow making sure that the software works as expected.

Smoke tests

At the end of each sprint, the QA team performs smoke testing. It has to prove that the main business logic has been implemented correctly and works seamlessly, along with the main functionality.

Regression tests

Developers change the code during the sprint. We perform regression tests to ensure that new functionality hasn’t harmed the previously added.

Load tests

As for load testing, it’s needed to check how the software works under moderate load. The server response time shouldn’t exceed the time in specification.

It’s not the final list. QA engineers perform more tests like stress, release, and interrupt tests. However, they are used rarely depending on project peculiarities and requirements.

There are several stages of software development, QA testing is one of the primary steps. This stage usually takes approximately  30% of the project development time. However, the number can vary, depending on the app type and business requirements.

The end of the testing stage guarantees a well-working and high-quality demo-product.

Types of Testing done at Gloify

Software tester is always responsible for the quality of application, The team at gloify doesn’t test code, but how it works.

There are two main ways to estimate the app’s quality — manual and automation.

  • Manual testing

From its name, these tests are done by hand by QA engineers. The team needs to check how the app works in the following conditions. Such tests are perfect for small projects. Also, it’s impossible to maintain only automated tests and get a perfectly working product. Manual and automated testing always come together.

  • Automated testing

In the case of big projects, we tend to use automated tests to speed the process. It’s common to use automated tests for the back-end part of the project. A QA engineer writes a test (code) that checks some significant parts of the code, part of complex logic, or a template scenario.

We at Gloify take pride in the Quality of Products and services we deliver Our Experts are just a call/chat away to answer all your questions.

Related Posts