Quality of Games – Is It the Responsibility of a Tester or Developer?

No votes yet.
Please wait...

Before we start searching for an answer to this question, we have to find a state meaning of such a concept as quality. Hence, we’ll protect the audience from various misunderstandings and logical inconsistencies.

International Organization for Standardization has a special department that defines a concept of software quality. Thus, we can get a correct interpretation of the “quality” concept there.

Quality (according to ISO 8402:1994) is the totality of software characteristics of an entity that bear on its ability to satisfy stated and implied user needs.

In other words, it is the measure of how good the software is and how fully it meets all the technical requirements.

Concept of Testability and Its Role in Game Testing

A well-known Murphy’s Law works at full capacity in the testing sphere: anything that is untested can be considered broken. Analysis of feature’s testability at any stage of its development is the main task of every tester. Execution of this task allows protecting a tester from a huge amount of potential defects.

Let’s imagine such a situation: the game designer developed a new feature, and you (QA specialist) don’t fully understand its nature. Thus, you cannot make a correct test case to check such functionality.

The designer created a very complex system that has a lot of combinations. It is always really difficult to test all these things.

If you don’t ask a programmer how to check new functionality with many tests at the development stage, then you shouldn’t employ such a feature at all. It will never work properly and negatively affect the quality of other features performance which may potentially interact with this one.

Who Is Responsible for the Quality of Game Functionality?

It is possible to get the desired quality of game functionality only due to the close interaction between the development and testing departments. All specialists should work together for reaching a positive outcome.

If you want to get an interesting and stable game, you have to maintain its quality in the early stages of development. If otherwise, it won’t work.

What Should a Programmer Do for a High-Quality Game?

1. Knowledge of the Game Structure

Any programmer should know well all the parts of the game. Hence, he/she will easily predict introducing bugs in any part of game functionality. For example, if the programmer changes the logic of achieving a main prize in the game, then he/she can tell a tester how to quickly complete levels to check this test case.

It is a common practice when a programmer tells a tester what and how should be tested. They mention those parts which may probably contain bugs. Or the programmer can tell how to test some files more effectively.

Computer games are a complex set of system functionality with a big list of various interactions. It is a great number of use cases each of which has to be thoroughly analyzed and examined.

If a programmer can help a QA engineer to make a qualitative test scenario, it definitely should be implemented on the projects of development/testing of game functionality. The sooner QA engineers detect a bug, the sooner developers fix it and give for retesting. As a result, a program will get less damage.

2. Code Review

This is a qualitative practice to improve the professional skills of any developer. The more qualitative code of a computer game is, the better quality of the product will be.

This practice can be referred not only to developers. For example, designers create wireframes that they consider to be a program code. It means, it is better to test their code as well.

Note: Several weeks of regression tests can replace hours of monotonous code review.

3. Smoke Testing of Their Changes

Initially, it is expected that the tester should deal exclusively with the tests. But it is not so. Imagine a situation when a programmer created a code that does not compile at all, or some files are not completely developed.

Eventually, the whole company will suffer, no one will be able to work properly and the company will take losses. If the situation with the code (or at least with the process of compiling it) is simple, then it’s a lot more complicated with the changes that designers constantly make.

The designer can change something in the middle of the project and forget to check it. But in any case, the tester must conduct hundreds of user cases to qualitatively verify the system’s performance.

As a result, tester wastes time to build a test version, conduct smoke testing, find a broken place, fix it, and give it to the development department. As you can see, it takes a lot of time.

However, it is possible to avoid such things in advance if the designer spends some time to perform smoke testing of his changes and give the bug-free code to the final build.

4. Programmers Must Consider the Wishes and Requirements of Testers

Without a doubt, it will be perfect if programmers give the testing department only those features that already have technical documentation and specific requirements. But sometimes it happens that it is the tester who has to independently compile a list of requirements.

And it’s good if there is relevant project documentation in the company. But if the documentation is old or missing at all, the tester cannot be sure of the correctness of the requirements based on his/her tests.

This means that the tester’s basic task is to analyze the tests and show the developer which data is valid and that the feature should technically correspond to this data.

All the recommendations described above will allow developers to significantly improve the quality of any software and any game project in any team.

How Can Testers Improve the Quality of a Game?

QA specialists search only for those defects that already exist in the product. Hence, they cannot improve the quality of the product.

At the testing stage, any game already has a certain level of quality. The tester has neither competencies nor the authority to improve the product. The testing process is an information service where QA engineers, as interested individuals, share with others the truth about the product under test.

Programmers make decisions regarding the program error correction based on information from testers. They can do it independently or after a meeting with managers. It is the development department that affects the quality of gaming software. Testers only control it!

At the same time, many problems can arise during testing. Because of them, software quality can significantly suffer. Here is a shortlist of such problems and their practical solutions.

1. Incompetence

Only junior QA cannot unilaterally achieve the desired result either in the testing process or in development. There is a perception that testers are the most skilled workers. So, you can hire up to 10 junior specialists for any game-related project. Thus, you will control the situation with product quality.

However, a lot of unqualified testers will never replace one professional and experienced specialist. Only qualified QA engineers are the basis and support of the development department.

It is impossible to develop a high-quality and in-demand product without the competent staff of the testing department.

2. A Few Testers

No doubt, most games are very complex technical systems with an unlimited set of user scenarios and different variations of game interactions. That’s why, theoretically, you cannot cover the entire game with tests.

Unfortunately, there is no universal system based on which one could find the right number of testers for a particular project. This is influenced by several factors at once: the size of a game, the amount of game mechanics, the product genre, and the technical linearity of the game process.

Even with such a variety of approaches, it is possible to find one appropriate criterion for the correct software development and verification process. It is believed that a sound relationship is when there are up to 4 developers for 1 tester. This is a ratio that we should constantly strive to, making some changes based on the specifics of a particular product.

3. Late Testing

Any game cannot be created immediately. It is a result of a long development process. Classically, this process is divided into stages and reporting periods. It is important for testers to realize the stage where the programmer is now. QA should give him/her the number of bugs for correction that are exclusively relevant for this stage.

You’d think, what’s the harm in notifying the programmer in advance about the bugs found? If we are talking about the final stage of giving the project to release, there is nothing to worry about. But if testers begin to describe low-priority bugs at the initial stages, this harms the overall process of game development.

A QA engineer spends time looking for low priority errors. As a result, such defects will accumulate in the bug tracking system and the tester will have to perform regression tests later, after the product release.

It is necessary to avoid such scenarios, constantly monitor the current stage of software development, and be aware of the current requirements for the feature being developed.


Game testing is some kind of communication service when QA and development departments should interact as much as possible. The quality of any computer game is primarily a level of communication between these departments, first of all.

A high-quality product is the result of the interaction of many processes, including testing, preparation of technical documentation and documentation for the client, implementation of useful innovations, and discussions. These are the main tasks for programmers and testers while working on any computer functionality.

Leave A Comment