Keeping the control over quality is the key to success when it comes to the app development process. For this reason, we pay much attention to QA testing introducing a team of experienced and dedicated QA engineers. They act in collaboration with other team members to enable an efficient development process at every stage.

Our mission is to establish a successful approach to stable and balanced architecture in addition to encouraging users’ experience. Keep in touch of our main issues when it comes to development process.

Efficient teamwork

The team includes at least two developers. Such approach lets us avoid any difficulties and low-quality code, which tends to get worse unless it is regularly reviewed by all developers. All our employees work in a team in site of the stage. They keep in touch with all changes and updates stay in the flow of the working process and offer some more efficient solutions.

We regularly arrange team meetings, brainstorming and other events that make it possible for us to fix all bugs, offer more functionality to the project, and add some improvements and modifications in case of necessity.

We streamline the workflow

Continuous Integration lets us establish a streamlined workflow and proceed with the coding that meets negotiated and approved standards. Here are some points you may be eager to know:

Continuous Integration Practice – Many remote teams often face the same problem when integration issues result in missing the deadline. One will hardly appreciate his or her project knocked off the schedule. Our practice helps us to avoid any of the above mentioned. We can observe any build we need and review it at any stage of the development process. Moreover, we can boast an efficient interaction with QA engineers brought by increased visibility. On the one hand, Continuous Integration will hardly allow getting rid of all bugs. On the other hand, it puts an ease on bug detecting and elimination;

Gitflow – The source quality is determined by the percentage of mess in it. For this reason, we establish a single standard for all our programmers to ensure the code clarity. All our developers are obliged to agree on those standards and work in accordance with them. Gitflow also helps us to follow all established standards. We use it for our every project to enable as many repository operations as possible. Such approach results in total understanding of the development process by our professionals. Gitflow helps to create an easy and efficient developing model.

Summing up, we need less time necessary for debugging and have an efficient tool to clear the code from all that mess.

Testing of units

Every time a dedicated development team needs to create an efficient architecture within the QA testing department, unit tests may appear to be extremely handy. You will hardly produce a clear perfect code without them. Unit lets us detect all bugs at the early stages reducing the time necessary for debugging. In other words, we will never face difficulties when going back to any stage.

Automatic library updates

We have successfully implemented an automatic update of all our libraries and frameworks. We use special tools like CocoaPods or Gradle depending on the target mobile platform. Those essential developing tools, which let us keep the control over the entire structure of the project. It includes not only setup but also work maintenance and update releases.

Control over quality

We keep an eye on every detail during the testing process. Our every team member makes his or her contribution trying to predict and examine all possible scenarios. We use the following approach to reach superior quality of the product:

  • Conducting a Test Plan – we use special test cases and plans to ensure a smooth and fast operation of the product on any type of device in site of the carrier, mobile platform, network, etc. For this reason, we use various QA testing methods and tactics. All our moves are reflected in a specially developed test plan in addition to detailed reports and testing stats. The plan indicates a particular module we are going to test, as well as the timeframe, environment, testing methods and more. Each iteration starts with a testing outline. We conduct special test cases that will provide a clear picture of what we are going to do. In other words, you will see a step-by-step tutorial of all testing procedures used for a specific module;
  • Efficient testing at All Stages – testing the project at its last stage is not enough to ensure 100% quality. For this reason, we keep an eye on every stage of the development process implementing different testing methods. Each and every part of the cycle ends up with bug fixing and QA testing. We go to the next iteration only in case everything is fine with the previous one;
  • Impact Testing – we often deal with parts that are not connected within the project or introduce some of its separate parts. This is when impact testing may come in handy. Every time we interfere with the developing process and test a particular iteration, we influence different areas. We need to be 100% sure all those sections run smoothly. At the same time, we use impact testing to reveal all possible connections between different parts of the project. It helps to determine whether they interact well with each other.
  • Regression testing – even when you have completed all testing procedure and fixed all the bugs detected, there is still a possibility of malfunctions and pitfalls when launching the project. Regression testing is yet the only efficient way to steer clear of any project crashes and developing misses. This stage is traditionally divided into two major parts. The first part includes running a verification test while the second one is all about smoke tests. They are necessary to have guarantees that other processes have not been affected during the entire testing procedure;
  • Crashlytics – the entire process of fixing bugs will hardly provide you a 100% guarantee that all bugs are gone. It is impossible to detect all of them, as some bugs are extremely difficult to recognize. They rarely meet, which makes it rather complicated to detect them. The product may interact wrongly with some latest OS versions or a particular type of device. It is impossible to predict all the issues beforehand. Crashlytics integration has proved to be a great solution to this problem. The system will inform you every time any bug takes place after the product is launched. Developers will have a chance to see a clear picture and steps that eventually led to pitfalls. In addition, the system delivers some other vital pieces of information including geolocation, type of device, OS version, language and more;
  • Compatibility testing – this type of testing is used to compare and contrast the current OS version with the previous one. Although being underestimated by the majority of app developers, this method is certainly worth paying attention.

We use all possible means to deliver superior quality product and protect you from all possible crashes and failures after release. We use various testing methods and take pride in our QA engineers and testers.

Published by manager
Content Marketing Manager