- QATestLab Blog >
- Game Testing >
- How to Calculate Your Game QA Budget Before Release
How to Calculate Your Game QA Budget Before Release
The samurai has no goal, only a path. Your studio has both: the launch target and the roadmap to get there. How you budget QA decides how much of that roadmap survives the trip. The marketing window is locked to a date someone already promised to a publisher. Then a week before submission, the frame rate collapses on a two-generation-old GPU nobody had in the test configs, the browser build stutters in Safari while running fine in Chrome, and the Jira board that said “Release Ready” that morning fills up with blockers.
Soft launch exists because no plan survives the final boss: real players. QA budgets break for the same reason, and nobody notices until the sprint where there is no time left.
In a September 2024 survey of 303 US game developers by modl.ai [1] (The State of Games QA), 77% admitted their latest title went out with less QA than it needed, and half said their budgets lagged behind the complexity they were building. With the build almost locked, someone has to choose between launching with the bugs and moving the date the trailer is already booked for.
The way out is to do the math before the scope starts multiplying. List the platforms and hardware your game must support, estimate testing hours per milestone, apply your own cost model, and keep a real reserve for retests and unplanned cycles. Most of that reserve goes to compatibility: a save that corrupts on the Steam Deck, a shader that compiles on one driver version and not the next, a mobile browser that runs out of memory halfway through a session.
The budget pays for catching that crash in week six of alpha, while it is still a ticket. The alternative is a store page where the fix arrives after the reviews do.
Why You Should Plan Your QA Budget Before Release
Studios that get funded know their numbers. Engine licenses, art outsourcing, server costs, a marketing spend tied to a launch window, a runway counted in months. QA is the line that stays vague in an otherwise sharp plan: everyone agrees it is needed, nobody sizes it, and it ends up absorbed into whatever is left at the end. Then validation gets compressed into the final sprint and leadership has to choose between cutting coverage and moving the date. Both choices show up on the P&L, just later and under a different name.
Late Bugs Cost More to Fix
A bug found during development is cheap. After launch, the same bug becomes a patch that has to pass store or platform review again, while players keep running into the problem until it ships. And the bill grows with every stage.
Release Dates Slip
Without a QA budget, testing gets squeezed into the last weeks before launch. Then the team has two options: ship with coverage gaps, or move the date. But moving the date is rarely free, as marketing spend and publisher agreements are planned around it. Each delay adds up in costs.
Platforms Can Reject Your Build
App Store rejects builds that crash, and consoles check every build against their technical requirements before the product goes live. That sends the review process back, eating up time. Investors start asking why the date moved while the team goes into crunch to fix and resubmit the build.
Ratings Drop, and Refunds Grow After Launch
Players decide on a game in the first hour or two. On Steam, they can get a refund within 14 days of purchase if they have played less than two hours. A crash in the first session can push a player to request that refund and leave a negative review. Negative reviews push the game down in store rankings, and new players see them first. A post-launch fix doesn’t bring back players or reviews.
What Makes Up a Game QA Budget
Game testing costs don’t grow evenly. A new gameplay mechanic adds some functional testing, and the extra hours stay within that area. Five new languages or a wider device matrix work differently. Each language and each device has to be checked across the whole game, so the hours multiply.
So it makes sense to break the budget into components. Some parts stay fairly stable. Others grow fast with every new device or language.
What goes into a game QA budget
Each testing component adds hours to the estimate. Budget sensitivity shows how strongly a component can move the total as the scope grows.
| Component | What it covers | When it is needed | Budget sensitivity |
|---|---|---|---|
Functional testing |
Whether core mechanics and progression work as designed | Every milestone, starting from the first playable build | MediumGrows with the number of features |
Compatibility testing |
How the game runs on real devices and OS versions | Before beta and before every release | HighEach new device adds hours |
Performance testing |
Frame rate and loading times on target hardware | From alpha, then again before release | MediumDepends on how demanding the game is |
Localization (LQA) |
Text, UI fit, local currencies, and cultural adaptation | After the localization kit is final, before release | HighGrows with every language |
Compliance/ |
Platform technical requirements and store rules | Before every submission, including patches | MediumFailed submissions add extra cycles |
Regression testing |
Checks that new builds did not break what already worked | After every new build or fix | HighThe number of cycles is hard to predict |
Usability/ |
Whether players understand the game and enjoy it | Prototype and beta | Low to mediumDepends on the number of sessions |
Test automation |
Repeated checks such as smoke and regression runs | Long projects with frequent builds or live ops | UpfrontCost that lowers regression hours later |
Test management and reporting |
Test planning and status reports for stakeholders | Throughout the project | LowUsually stable across the project |
Total: 9 components that shape a game QA estimate
Going over budget is the norm. In a 2023 survey of 537 studios, only 15% finished their most recent project on budget, and one in five went 50% to 100% over [2]. Producers in that survey named the reason: dependencies nobody sees while planning, which surface once the work is already running. Testing is where many of them land, because a change to one part of the game has to be verified against everything it touches.
That is why the components marked High are worth planning first. Their hours grow with every device, language, and build you support.
What Drives Game QA Costs Up or Down
Game QA cost estimates can go wrong before release because teams treat every scope change as if it adds the same amount of work. As the component table above shows, scope grows in two different ways.
- Adders (Linear Scope). Adding a new gameplay part predictably increases testing time.
- Multipliers (Compounding Scope). Platforms, the device matrix, languages, and builds multiply the work.
The difference shows up quickly in numbers. Take a plan with 100 testing hours per cycle on one platform, in one language, over four test cycles. That is 400 hours, and it would multiply each time you add another unit to test. Here is what a single change does to it:
How scope changes move game QA hours
Starting from a 400-hour baseline, an adder raises the total by a fixed amount, while a multiplier scales the work in every test cycle.
| Scope change | Type | Total hours | Change |
|---|---|---|---|
Baseline plan |
— | 400 |
— |
New game mode+10 hours per cycle |
Adder | 440 |
+10% |
Two extra languages+25 hours per cycle each |
Multiplier | 600 |
+50% |
Two extra builds6 cycles instead of 4 |
Multiplier | 600 |
+50% |
Second platformthe full suite runs again |
Multiplier | 800 |
+100% |
Baseline: 400 hours across 4 test cycles, about 100 hours per cycle
Core Game QA Cost Drivers
Each factor below raises or lowers the number of test hours your game will need. Most of them depend on decisions made before testing starts, which makes them easier to plan for than to fix later. The table shows what pushes each factor up and what keeps it down.
What moves game QA costs up or down
The same game can need very different QA budgets. These factors show where extra hours come from and what keeps them under control.
| Factor | What drives costs up | What brings costs down |
|---|---|---|
Platforms and stores |
A simultaneous launch on several platforms. Each one has its own SDK checks and certification. | A lead platform first. Fix core bugs before porting the game. |
Device matrix |
Budget devices and custom Android skins like One UI or HyperOS. Each one adds manual testing on real hardware. | A device list based on market share for your genre and region. |
Genre, architecture, and monetization |
Real-time multiplayer and monetization systems like IAP or ad mediation. They create many edge cases. | Single-player offline gameplay and standard payment SDKs. |
Content volume |
Long campaigns and branching stories. Testers need full playthroughs to catch progression blockers. | Short sessions and modular levels that can be tested separately. |
Localization (LQA) |
Non-Latin scripts, UI text overflow, regional currencies, and cultural adaptation. Each locale adds UI and market checks. | A string freeze before LQA, flexible UI layouts, and launching only in priority markets with proven revenue. |
Build stability and delivery |
Irregular builds with untested changes. Blockers stop test runs halfway, and QA has to start again. | A fixed build schedule and a quick developer check before each handoff. |
Schedule compression |
Testing squeezed into the last weeks. That takes a bigger team and overtime, and rushed passes miss bugs. | QA spread evenly from alpha. A smaller steady team catches defects while they are cheap to fix. |
Release strategy and regression |
A global launch without a soft launch, plus fully manual regression in every sprint. | A soft launch or early access, plus reusable test cases and automated smoke tests. |
8 factors that move a game QA estimate up or down
Case in point: Cyberpunk 2077
What happened. The game launched on December 10, 2020. On PS4 and Xbox One, it shipped with game-breaking bugs and performance problems, and even PS4 Pro and Xbox One X struggled.
What it cost. Sony pulled the game from the PlayStation Store and refunded digital buyers [3]. In its 2020 financial report, CD Projekt recognized about $51.2 million in provisions for returns and expected sales adjustments tied to the launch [4].
What it means for your budget. The studio later admitted the console versions needed more attention. Every platform in a release plan needs its own share of testing hours. If one gets less, the cost shows up after launch, not before.
How to Calculate Core Testing Hours on Real Devices: Compatibility, Functional, and Localization
A game QA plan rests on three testing types. Functional testing scales with the number of features and scenarios. Localization scales with the number of languages. Compatibility scales with devices, and it is the hardest of the three to predict, because the hours depend on two choices at once: how many devices you test and how deeply you test each one. The steps below show how to turn those choices into hours. The same logic then applies to the other two types, with features and languages in place of devices.
How to Estimate Compatibility Testing Hours
Devices→Depth→Hours
Tap a step to mark it done
Download the PDF checklistStep 1. Define Your Target Markets and Audience
Start with where the game will launch and who will play it. Use analytics from your previous titles if you have them. If not, use public market share data for your target regions as a starting point. The markets you pick here also set your localization scope, so decide them once and use them for both.
Step 2. Build a Device Matrix by Tier
List the devices your players actually use and group them into three tiers.
- Min-spec. The weakest devices you officially support. They show where performance breaks first.
- Mid-range. The devices most of your audience owns. They make up the largest share of the list.
- Flagship. Top models with the latest OS versions and the highest screen resolutions.
For each device, record the OS version, chipset and GPU, RAM, and screen aspect ratio. These parameters decide which issues a device can reveal, so two phones with similar specs can often replace each other.
Step 3. Set an Audience Coverage Target
Decide what percentage of your players the device matrix should cover. Each additional device typically adds less audience coverage, while testing effort grows proportionally. For example, expanding a matrix from 10 to 11 fully tested devices increases device-testing hours by 10% per cycle, even if the additional device covers only 1–2% more players. At some point, the extra testing effort outweighs the coverage gained.
Step 4. Define the Testing Depth per Device
Not every device needs the full checklist. Run full compatibility checks on min-spec devices and on the models with the largest audience share. A short smoke check is enough for the rest: install, launch, core gameplay, and in-app purchases. Functional testing runs in depth, but only on one or two reference devices per platform.
Step 5. Estimate Hours per Device per Cycle
Estimate how long one test pass takes on one device. Count setup and installation, the checks themselves, and bug logging time. A full checklist takes longer on a game with more content and more systems to check. A smoke check stays short regardless of game size.
Step 6. Multiply by the Number of Test Cycles
Count how many builds will go through testing before release. A typical plan includes alpha, beta, and the release candidate, plus extra passes after major fixes. Take this number from your build schedule. A guess comes up short. The cycle count is the one multiplier that applies to all three testing types at once, which is why it moves the total more than anything else on this list.
Step 7. Add a Reserve for Retests
Every bug found on a device needs a recheck on that device after the fix. These retests do not appear in the plan, but they always happen. Add them as a separate reserve on top of the total.
Putting It Together
The calculation looks like this:
Total hours = (full-check devices × hours per full check + smoke-check devices × hours per smoke check) × number of cycles + retest reserve
For example, 10 devices with a 6-hour full check and 20 devices with a 1.5-hour smoke check total 90 hours per cycle. Four cycles give 360 hours. A 20% retest reserve brings the total to 432 hours.
Multiply the result by your hourly rate to get the budget.
Get Your Hour Range with the QA Game Estimator
The seven steps are straightforward on paper. In a real project, they often stall: the device list isn’t final, the build schedule keeps shifting, or it’s unclear how many hours a full check on one device actually takes. And every time the scope changes, the math starts again.
For these cases, the QATestLab game testing team built the QA Game Estimator. It takes about two minutes and seven short questions:
- testing types (compatibility and functional are included, localization is optional);
- platforms and game genre;
- project stage;
- device coverage, from the top 5–10 devices to 30+ including low-end models;
- features such as multiplayer, in-app purchases, live ops, or social login.
You can see your results on the end page or receive detailed results by email as a PDF once you click the “Email me Estimate” button. Here is what is inside.
An hour range per testing type
Each type gets a minimum–maximum range and a typical value in the middle, plus the total converted into calendar time: for example, roughly 3–7 weeks for one dedicated tester, and less with a small team. For an action game on Android and PC at the prototype stage, with standard device coverage and social login, it would look like this:
Estimated QA hours by testing type
Each bar shows the estimated range of hours. The marker shows the typical value inside that range.
| Testing type | Hours | Typical |
|---|---|---|
Compatibility |
55–120 |
~90 |
Functional |
70–145 |
~110 |
Total |
125–265 |
— |
Range of hoursTypical valueScale: 0–270 hours
How are the numbers calculated?
Base hours come from the scope you selected, then a complexity factor adds platform and feature risk, such as Android fragmentation, in-app purchases, or live ops. The same answers always give the same numbers.
What else is in the PDF?
A short testing plan written for your genre, platforms, and stage. The assumptions behind the range and what falls outside it. What you get if you go ahead: bug reports with reproduction steps and severity, a coverage matrix, status updates, and retest cycles.
Next steps
An NDA, a testable build, and a short call to agree on scope and price. The estimate shows effort in hours; cost depends on expertise, complexity, and the engagement model.
Conclusion
Most QA budget overruns start with the multipliers: every platform, device, language, and build repeats the test plan. Agree on them early, take the number of cycles from your build schedule, and the hours stop being a surprise. Put those hours into your own cost model, and you have a budget you can defend to investors and publishers.
You don’t need a finished test plan to get a first number. The QA Game Estimator turns your platforms, device coverage, and project stage into a testing hour range in about two minutes. With that range in hand, a short call with a QATestLab game testing specialist is the next step. It will confirm the scope and the device matrix and show where the hours are likely to grow.

FAQ
How can I quickly estimate QA hours for my game?
The fastest way is the QA Game Estimator. To check the result by hand, multiply the hours per device by the number of devices and test cycles, then add 15–20% for retests. For a matrix of 30 devices over four cycles, with 10 full checks and 20 smoke checks, that comes to about 432 hours of compatibility testing.
Why do pre-release QA estimates frequently exceed initial budgets?
Most QA budgets go over because teams expect scope to grow evenly. New features add testing hours step by step. A new platform or a longer device list multiplies the work, because the whole test suite has to run again on each one.
When should a studio start planning QA?
QA planning should start before production, when the team chooses release platforms and markets. Testing itself begins with the first playable build and grows toward release. If planning starts late, the testing window shrinks, the team needs more testers at once, and the release date becomes the buffer.
What is the most cost-effective hardware setup for device testing?
A QA partner with a real device lab. Ours has 500+ devices, so engineers test the matrix your audience actually uses — real hardware catches what emulators miss. An in-house lab pays off only if you ship often on the same platforms.
How should retests and regression be factored into the QA budget?
Plan them as two separate lines. Retests are rechecks of fixed bugs on the device where they were found, and a 15–20% reserve of planned hours covers them. Regression depends on how many builds go through testing, so take the number of cycles from your build schedule.
References
[1] modl.ai, “The State of Games QA.” https://modl.ai/state-of-games-qa-report
[2] Rendered Venture Capital & Griffin Gaming Partners, “Game Development Report 2023.” https://griffingp.com/wp-content/uploads/2024/02/2023-Game-Development-Report.pdf
[3] Video Games Chronicle, “Sony has removed Cyberpunk 2077 from the PlayStation Store and is offering refunds.” https://www.videogameschronicle.com/news/sony-has-removed-cyberpunk-2077-from-the-playstation-store-and-is-offering-refunds/
[4] CD PROJEKT, “Consolidated Financial Statement of the CD PROJEKT Group for 2020.” https://www.cdprojekt.com/en/wp-content/uploads-en/2021/04/consolidated-financial-statement-of-the-cd-projekt-group-for-2020.pdf
Learn more from QATestLab
Related Posts:
- PGC Barcelona 2026: Indies, Demos, and Player Experience in Focus
- Managed Game Testing: Keep Your QA Stable During Summer Vacations
- Pocket Gamer Connects London 2026: AI+Automation, Cross-Device QA, and Indie Games Highlights
About Article Author
view more articles



