- Functionality bugs. Some functions in the game don’t work or don’t work correctly. For example, the application crashes when you open the settings;
- Interface bugs. Graphics are distorted, elements are not in the correct places, the text does not fit into the space allotted;
- Localization bugs. Errors in texts, untranslated strings. For example, instead of the translation there are placeholders like “russian_text_001”;
- Performance bugs. The application runs slowly on a device. For example, during a character attack animation, FPS significantly decreases on high-end segment devices;
- Logic and balance bugs. The balance and game logic settings prevent the game from being completed or do not allow players to complete tasks. For example, a character deals 100 damage instead of the 150 promised in the game;
- Technical bugs. The game does not work correctly on an unstable Internet connection, for example, the application cannot connect to the server on 3G networks;
- Compatibility bugs. The game simply does not work on a compatible device or runs with critical errors.

- maximum priority bugs are ones which clearly prevent the player from advancing, or affect the application’s money-making potential;
- medium priority bugs are visible to users, but do not affect the player’s progress or the application’s revenue;
- low priority bugs are almost invisible to players, show up rarely or only in very specific, limited conditions, and do not interfere with progress or revenue.

- Bugs affecting users. These affect the popularity of the application and the average rating in app stores;
- Bugs affecting the business. These may not hinder users. For example, the game is too simple: players love this, but it doesn’t encourage them to invest their money into the game;
- Bugs affecting the development team. This is when a functionality is not implemented as it was conceived by the team, but users don’t notice (they aren’t aware of how it was conceived), and it doesn’t interfere with application revenue.
- First of all, it depends on the development team’s experience.
- The second most important factor is the project’s technical complexity. The chances of bugs appearing are directly proportional to the amount of code and the number of libraries used.
- The third is the number of possibilities in the game and the overall variety of gameplay.
- Network mode and the way players interact with each other is another serious item. For network mode, developers often do closed testing to adjust the balance and look for non-obvious bugs, even in games that have already been tested at the production stage.
- And of course, direct dependence on the effectiveness of testing at an early stage of development. The fact is that the more bugs that are found as soon as possible, the less likely it is that these bugs will later lead to the emergence of new ones.

- RPGs with network mode. An expansive world, a lot of scenes where players interact with each other;
- Open world games. An immense amount of player behavior possibilities which need to be carefully tested;
- Any game with a strong graphical component. It is almost impossible to optimize a game equally for all devices, if we are not talking about console titles.
- Games in the match-3 genre. Here the player is limited by the playing field and combinations of pieces, bonuses, and the number of game mechanics;
- Games in the hidden object genre, where the player’s freedom is generally limited
- Fighting games;
- Casual games where the action takes place on one screen: time managers, clickers, shoot’em up, etc.

