Game QA Checklist: Pre-Release Testing for Web Games

Functional Testing Pass

Core gameplay loop: Verify the primary game mechanic works from start to finish. For a platformer: run, jump, land, collect, reach the exit. For a puzzle game: select, place, solve, advance. For a shooter: aim, fire, hit, score. Play through the first level or tutorial completely and verify that every interaction produces the expected result.

Player controls: Test every input binding (keyboard keys, mouse buttons, touch areas, gamepad buttons). Verify that controls respond immediately without noticeable delay. Test simultaneous inputs (jump while moving right). Test edge cases (pressing two conflicting keys simultaneously, pressing a control while the game is paused).

Scoring and progression: Verify that the score increments correctly for each scored action. Verify that level completion triggers the correct transition (next level, victory screen, unlockable). Verify that experience points, currency, or other progression metrics accumulate correctly and persist across sessions.

Inventory and items: If the game has collectibles, verify picking up an item adds it to the inventory, using an item removes it or decrements the count, inventory limits are enforced (cannot exceed maximum), and items have the correct effects when used.

Save and load: Save the game at a specific point. Close the browser tab entirely. Reopen the game. Load the save. Verify that the player position, inventory, score, settings, and progression are all correct. Test saving at different points in the game and loading each save.

Pause and resume: Pause the game. Verify that all entity movement, physics, AI, and timers stop. Verify that the pause menu is navigable. Resume the game. Verify that everything continues from exactly where it paused. Test pausing during critical moments (mid-jump, during a boss attack, while a timer is counting down).

Game over and restart: Trigger the game over condition (run out of health, time, or lives). Verify that the game over screen displays correctly. Verify that restarting resets the game state completely (no ghost data from the previous attempt). Verify that the player can return to the main menu from the game over screen.

Browser Compatibility Checks

Chrome Desktop (Windows/macOS): Full playthrough. Verify rendering, audio, input, and performance. This is your baseline, so any issues here are critical.

Firefox Desktop: Full playthrough. Check for WebGL shader differences (Firefox uses a different OpenGL backend than Chrome). Verify audio timing. Check gamepad button mappings if gamepad is supported.

Safari macOS: Full playthrough. Check for WebGL rendering differences (Safari uses Metal backend). Verify audio autoplay handling. Check for any JavaScript API differences (Safari sometimes lags behind in implementing newer APIs).

Chrome Android (real device): Full playthrough. Verify touch controls work. Verify viewport sizing with address bar visible and hidden. Verify performance on the test device. Verify audio plays after first touch.

Safari iOS (real device): Full playthrough. Verify touch controls. Verify viewport behavior with dynamic toolbar. Verify audio autoplay restrictions are handled. Check for Safari-specific WebGL limitations. Verify the game does not trigger unintended zoom (pinch-to-zoom should be disabled for games).

Console errors: Open DevTools on each browser and check the console for JavaScript errors, warnings, and deprecation notices during a full playthrough. Any error, even one that does not cause a visible bug, should be investigated. Uncaught exceptions can cause intermittent failures that are difficult to reproduce.

Performance Benchmarks

Frame rate: Run the most demanding scene (most entities, most effects, most complex rendering) for 60 seconds. Record average FPS, minimum FPS, and 1% low FPS. Compare against performance budget. Desktop target: 60 FPS sustained. Mobile target: 30 FPS sustained minimum.

Load time: Clear browser cache. Load the game. Measure time from navigation to interactivity (when the player can first interact with the game). Target: under 5 seconds on broadband, under 10 seconds on mobile 4G. Use Lighthouse to get a standardized measurement.

Memory usage: Play the game for 15 minutes. Record JavaScript heap size at the start and end. If end usage is more than 20% higher than start usage (after accounting for level-specific content), investigate for memory leaks. Check that usage stays below 256 MB on mobile and 1 GB on desktop.

Asset sizes: Check total download size in the Network panel. Total initial download should be under 5 MB for broadband targets and under 2 MB for mobile-first games. Verify that textures are compressed (basis/KTX2 or WebP), JavaScript is minified and gzipped, and audio is in an efficient format (OGG Vorbis or MP3, not WAV).

Mobile-Specific Verification

Touch controls: Every interactive element responds to tap. Virtual joysticks and buttons work correctly. Multi-touch interactions work (if applicable). No accidental browser gestures (pull-to-refresh, pinch-to-zoom, edge swipes) interrupt gameplay.

Orientation: If the game supports landscape only, verify the orientation lock works on Android. Verify that a "rotate device" message appears on iOS (where orientation locking is not available). If the game supports both orientations, verify that rotating the device resizes the canvas and repositions UI correctly.

Audio: Audio plays correctly after the first user interaction. Audio pauses when the app goes to background and resumes on return. No audio glitches when switching between apps.

Interruptions: The game pauses correctly when receiving a phone call. The game pauses when a system notification overlays the screen. The game resumes correctly after the interruption. No controls are stuck in a pressed state after the interruption.

Safe areas: Game UI does not render behind the notch on notched phones. Critical controls are not placed in the bottom safe area on phones with gesture navigation bars. Test in both landscape orientations if the game supports landscape.

Deployment Verification

Staging test: Deploy to staging environment. Run a smoke test (load, play first level, save, load, verify) on staging before promoting to production. Verify that the staging build matches the intended release version.

Asset serving: Verify that all assets load from the CDN (not the origin server). Verify that cache headers are set correctly (long cache for versioned assets, short or no cache for HTML). Verify that gzip or brotli compression is active for text assets (check the Content-Encoding response header).

Analytics and monitoring: Verify that analytics events fire correctly (page views, game starts, level completions, errors). Verify that error reporting captures JavaScript errors with stack traces. Check that the analytics and error reporting tools show data from the staging test.

SEO and metadata: Verify that the page title, meta description, and Open Graph tags are correct. Verify that the game has a working screenshot or preview image for social media sharing. Verify that the sitemap includes the game's URL.

Rollback plan: Confirm that you can quickly revert to the previous version if a critical bug is discovered after deployment. For CDN-hosted games, this means keeping the previous version's assets available and having a one-command deploy that points the CDN to the old version.