These skills do not affect the main grade but show the breadth of your profile.
AI Coding Assistants
▼
Uses ChatGPT/Claude for assistance with writing test cases and bug reports. Formulates simple prompts for generating test scenarios, reviews and edits AI responses.
Applies AI assistants to accelerate QA tasks: test data generation, crash log analysis, creating test scripts. Critically evaluates AI outputs for game-specific errors.
Integrates AI assistants into QA processes: automatic bug classification, generating regression test cases from changelogs. Configures custom instructions for game QA context.
Defines AI usage strategy for QA department. Builds prompt libraries for typical QA tasks, evaluates ROI of AI tools, establishes usage guidelines.
Uses GitHub Copilot for test code autocompletion. Accepts suggestions for typical assertions, test setup/teardown blocks. Verifies generated code for correctness.
Effectively applies Copilot for writing automated tests: generating page objects, test data builders, mock objects. Guides generation through comments and naming conventions.
Configures Copilot workspace for QA project: custom instructions for test framework, code snippets. Uses Copilot Chat for refactoring test code and analyzing failures.
Defines Copilot adoption strategy for QA automation team. Establishes usage best practices, evaluates impact on productivity and test code quality.
Algorithms & Data Structures
▼
Understands basic algorithms and their complexity (O-notation) for evaluating game system performance. Recognizes potential performance issues from suboptimal algorithms in code.
Applies algorithm knowledge for analyzing performance bugs: identifies O(n²) operations in game loops, finds bottlenecks in pathfinding, sorting. Evaluates algorithmic complexity of backend logic.
Uses algorithm knowledge for designing performance benchmarks. Analyzes spatial partitioning, collision detection algorithms, evaluates scalability of game systems as content grows.
Defines algorithmic review standards for QA team. Establishes approaches for testing scalability: load scenarios, stress testing for matchmaking, leaderboards, inventory.
Understands basic data structures (arrays, hash tables, trees) for analyzing game systems. Uses knowledge for formulating more precise bug reports about data issues.
Applies data structure knowledge for testing save/load systems, inventories, skill trees. Understands JSON/XML/protobuf game data formats, tests data integrity and migration.
Designs test strategy for complex game data structures: graph-based quest systems, spatial hash maps, ECS components. Validates data serialization between client and server.
Defines approaches to data integrity testing at studio level. Establishes strategy for testing data migration between game versions, implements automated data validation pipeline.
API Management
▼
Documents QA processes: test plans, bug report templates, test case documentation. Writes testing guides.
Creates QA documentation: test strategy documents, automation framework guides, reporting templates.
Designs QA documentation strategy: living test docs, automated reports, knowledge base.
Defines documentation standards: mandatory test docs, review process, knowledge management.
Application Security
▼
Understands security for game QA: tests auth flows, cheat prevention, input validation. Verifies basic security requirements.
Tests game security: cheat detection, packet manipulation, memory exploitation. Automates security testing.
Designs security testing strategy: penetration testing games, anti-cheat validation, economy exploitation testing.
Defines security testing standards: mandatory security tests, anti-cheat validation, vulnerability response.
Verifies secure coding in games: tests input validation, auth flows, data encryption. Validates security requirements.
Tests game security: SQL injection, XSS in web components, secure API usage. Automates security scanning.
Designs security testing: comprehensive game security testing, penetration testing, vulnerability assessment.
Defines security testing standards: mandatory security tests, vulnerability management, security review process.
Benchmarking
▼
Uses basic profiling tools: Unity Profiler, Unreal Insights, PIX for Windows. Takes profiles in problematic scenes, captures screenshots of results for bug reports.
Systematically profiles games: CPU profiling (hot functions, GC pressure), GPU profiling (draw calls, shader complexity), memory profiling (allocations, fragmentation). Interprets flame charts.
Designs benchmarking pipeline: automatic profile collection, build-to-build comparison, trend analysis. Uses platform-specific profilers (RenderDoc, NSight, Xcode Instruments).
Defines profiling strategy for QA department. Implements continuous profiling in CI, establishes dashboards for trend tracking, trains team in profile interpretation.
Caching
▼
Tests Redis in game context: checks cache consistency, session data, leaderboard data. Validates cache invalidation.
Automates Redis testing: cache behavior validation, TTL testing, failover testing. Checks data consistency after restarts.
Designs Redis testing strategy: comprehensive cache testing, performance benchmarks, failover validation.
Defines Redis testing standards: cache testing requirements, performance benchmarks, reliability testing.
CI/CD
▼
Understands basic GitHub Actions for game QA: running automated test workflows for game builds, reading CI logs for test failures and build issues, understanding pipeline status for release readiness. Follows team conventions for game QA CI integration.
Independently creates GitHub Actions workflows for game QA: configures automated test execution for game builds, implements test reporting and artifact collection steps, automates build distribution for QA testing. Manages game QA CI pipeline configurations.
Designs CI/CD architecture for game QA: optimizes test execution pipelines for game build coverage, implements progressive testing gates across build stages, architects automated regression testing for game releases. Mentors QA team on CI/CD best practices for game quality assurance.
Defines DevOps strategy for game QA: establishes CI/CD standards for game quality gates, implements platform engineering approaches for test automation infrastructure, drives adoption of continuous testing practices in game development pipelines.
Clean Code & Refactoring
▼
Understands basic code quality principles for reading and analyzing test scripts. Follows coding conventions when writing automated tests, uses meaningful variable and function names.
Applies code quality principles when developing automated tests: DRY, KISS, page object pattern. Uses linters (ESLint, pylint) for test code, maintains test suite readability.
Designs coding standards for test framework: style guides, review checklist, test naming conventions. Implements static analysis for test code, ensures maintainability.
Defines code quality standards for QA automation team. Implements code review process for test code, establishes quality metrics (test coverage, flakiness rate, maintenance cost).
Cloud Providers
▼
Works with AWS for QA: tests game services on AWS (GameLift, DynamoDB). Sets up test environments in cloud.
Automates QA in AWS: cloud test environments, load testing infrastructure, automated deployment verification.
Designs cloud QA infrastructure: scalable test environments, cloud-based load testing, multi-region testing.
Defines cloud QA standards: test environment provisioning, cost management, infrastructure requirements.
Code Review
▼
Participates in code review of test scripts as a reviewer. Checks basic aspects: assertion correctness, code readability, presence of comments. Leaves constructive feedback.
Conducts code review of automated tests and test utilities. Checks test isolation, correctness of wait/retry logic, proper test data management. Identifies potential flaky tests.
Reviews architectural decisions in test framework. Evaluates extensibility, maintainability, performance of test code. Checks integration with CI/CD and reporting.
Defines code review process for QA automation team. Establishes review checklist, implements automated review tools (SonarQube), trains junior engineers in review practices.
Concurrency & Parallelism
▼
Understands async for game QA: tests real-time game events, async matchmaking, network callbacks. Handles async test assertions.
Tests async game systems: multiplayer synchronization, server-client event flow, async game state updates.
Designs async test strategies: testing distributed game state, async event validation, timing-sensitive test scenarios.
Defines async testing standards: patterns for testing real-time systems, timing tolerance, async assertion guidelines.
Understands multithreading for game QA: tests concurrent game sessions, parallel test execution. Identifies race conditions.
Tests concurrent game systems: multiplayer synchronization, parallel game state, thread safety. Automates concurrency tests.
Designs concurrency testing: race condition detection, deadlock testing, parallel test infrastructure.
Defines concurrency testing standards: mandatory thread safety tests, parallel test policies, race condition detection requirements.
E2E Testing
▼
Runs simple Selenium tests for web versions of games and game portals. Understands basic locators (id, class, xpath), writes tests for authorization and navigation.
Develops Selenium automated tests for game studio web tools: admin panel, analytics dashboard, item shop. Applies explicit waits, page object pattern for stable tests.
Designs Selenium framework for web components of game ecosystem: launcher, web store, community portal. Integrates with Selenium Grid for cross-browser testing.
Defines web automation strategy for QA department. Implements Playwright/Cypress as alternative to Selenium for modern web components, establishes hybrid approach.
Game Design
▼
Tests basic economic mechanics: buying/selling items, earning currency for quests, crafting costs. Checks balance for obvious exploit opportunities.
Systematically tests game economy: currency flows, sink/source balance, marketplace mechanics. Checks edge cases: currency overflow, negative balance, item duplication.
Designs economy testing strategy: simulation-based validation, long-term balance testing (1000+ hours of progression). Tests monetization compliance (loot boxes, gacha) per regulatory requirements.
Defines economy QA standards for the studio. Implements automated economy simulation, establishes metrics framework for balance evaluation (Gini coefficient, inflation rate).
Understands basic game mechanics concepts: player input, physics interactions, and state machines. Tests core gameplay loops following test plans. Identifies and documents gameplay bugs related to mechanics behavior and edge cases.
Independently implements Game Mechanics Design in game automation tools. Optimizes performance. Works with profiler.
Designs comprehensive test strategies for complex game mechanics systems. Tests balancing, progression curves, and emergent gameplay interactions. Develops automated testing frameworks for mechanics regression and performance validation.
Defines QA strategy for game mechanics across the project. Establishes testing standards for gameplay systems, balancing validation processes, and automated mechanics regression suites. Coordinates QA efforts with game designers on feature acceptance criteria.
Game Engines
▼
Understands the fundamentals of Unity Engine. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently implements Unity Engine in game automation tools. Optimizes performance. Works with profiler.
Designs solutions with Unity Engine for production games. Optimizes for target platforms. Mentors the team.
Defines technical strategy for Unity Engine. Establishes development standards. Coordinates technical direction.
Game Infrastructure
▼
Verifies basic analytics events in the game: installation tracking, sessions, progression. Checks correctness of event sending to analytics backend (Firebase, GameAnalytics).
Tests full analytics pipeline: validates event schema, checks data accuracy in dashboards, tests funnel tracking. Identifies missing events and incorrect parameters.
Designs analytics QA strategy: automated event validation, data integrity checks, real-time monitoring. Tests A/B test framework, attribution tracking, GDPR compliance.
Defines analytics QA standards for the studio. Implements automated event coverage tracking, establishes data quality metrics, coordinates with analytics team on dashboard validation.
Understands basic multiplayer architecture: client-server, P2P, dedicated servers. Tests basic multiplayer scenarios: join/leave, host migration, player limit.
Tests multiplayer systems: lobby management, party system, voice chat, anti-cheat. Checks cross-play between platforms, tests edge cases with varying player counts.
Designs multiplayer QA strategy: automated bot testing for large-scale sessions (64+ players), dedicated server scaling testing, cross-region matchmaking validation.
Defines multiplayer QA standards for the studio. Implements automated multiplayer test environment with 1000+ bots, establishes cross-play certification matrix.
Game Platforms
▼
Tests mobile games on basic devices: checks installation, launch, touch input, orientation. Finds bugs with UI scale, safe area, notch/punch-hole compatibility.
Systematically tests mobile games: device fragmentation (50+ devices), thermal throttling, battery drain, interrupts (calls, notifications). Tests IAP flow and store compliance.
Designs mobile QA strategy: device farm integration (Firebase Test Lab, AWS Device Farm), automated compatibility testing. Defines minimum spec, tests low-end devices.
Defines mobile QA standards for the studio. Implements automated device testing pipeline, establishes device tier matrix, coordinates store review compliance (App Store, Google Play).
Tests games on PC and consoles: checks launch, basic graphics settings, controller input. Knows basic TRC/TCR/Lotcheck requirements for PlayStation, Xbox, Nintendo Switch.
Systematically tests PC/console builds: hardware compatibility (GPU vendors, driver versions), controller remapping, HDR, achievements/trophies. Conducts pre-certification checks.
Designs PC/console QA strategy: certification testing pipeline (TRC/TCR/Lotcheck), hardware compatibility matrix. Automates certification checklists, coordinates with first-party QA.
Defines platform QA standards for the studio. Manages certification process for 3+ platforms, builds relationships with first-party QA teams, optimizes submission timeline.
Tests web games in major browsers: Chrome, Firefox, Safari, Edge. Checks loading, input, rendering. Finds bugs specific to WebGL/WebGPU, audio autoplay restrictions.
Systematically tests web games: cross-browser compatibility, performance across different GPUs, memory limits in browser, touch support for mobile browsers. Tests PWA functionality.
Designs web game QA strategy: automated cross-browser testing via BrowserStack/Sauce Labs, WebGL performance benchmarking, service worker testing for offline mode.
Defines web game QA standards for the studio. Implements automated browser testing pipeline, establishes browser support matrix, coordinates with web platform team.
Game Programming
▼
Tests basic game AI behavior: NPC pathfinding, enemy reactions, patrol routes. Finds bugs when AI gets stuck, walks through walls or doesn't react to the player.
Systematically tests AI systems: behaviour trees, state machines, utility AI. Checks AI difficulty scaling, companion AI, enemy group tactics. Creates test scenarios for edge cases.
Designs AI testing strategy: automated playtesting for AI behavior validation, metrics-driven evaluation (kill/death ratio, time-to-complete). Tests ML-based AI for fairness.
Defines AI QA standards for the studio. Implements automated AI validation pipeline, establishes approaches for testing procedural AI content and adaptive difficulty systems.
Tests basic character animations: idle, walk, run, jump, attack. Finds bugs with blending, T-pose, floating, clothing and weapon clipping with character body.
Systematically tests animation systems: state machine transitions, IK (inverse kinematics), animation blending. Checks animation events (footsteps, VFX triggers) for synchronization.
Designs animation testing strategy: automates screenshot comparison for animation states, tests procedural animation and motion matching on edge cases.
Defines animation QA standards for the studio. Implements automated animation validation pipeline, establishes checklist for each animation state, coordinates with art team.
Tests basic game audio: SFX playback, music, voice lines. Finds bugs: missing sounds, clipping, incorrect volume, non-working audio triggers.
Systematically tests audio systems: 3D spatialization, occlusion, reverb zones, dynamic mixing. Checks audio middleware (Wwise, FMOD) for correct parameters and transitions.
Designs audio QA strategy: automated audio validation (silence detection, clipping detection), adaptive music system testing, platform-specific audio compliance.
Defines audio QA standards for the studio. Implements automated audio regression testing, establishes audio compliance checklist for platform certification (Dolby Atmos, 3D Audio).
Tests basic network interaction: server connection, matchmaking, ping display. Checks behavior on disconnect/reconnect, timeout and high latency (200ms+).
Systematically tests networking: packet loss simulation, jitter, bandwidth limitations via Network Link Conditioner/clumsy. Checks state synchronization between clients.
Designs network testing strategy: automated testing of various network conditions, validation of netcode (client prediction, server reconciliation, lag compensation).
Defines network QA standards for the studio. Implements automated network testing lab with programmable network impairment, establishes certification criteria for online modes.
Tests basic game UI elements: menus, HUD, inventory, dialog windows. Checks correct rendering at target resolution, finds visual artifacts and overlap.
Conducts systematic UI testing: checks all resolutions and aspect ratios, tests gamepad/keyboard/touch navigation. Validates accessibility (fonts, contrast, subtitle size).
Designs UI test matrix for cross-platform title. Automates screenshot comparison for UI regression. Tests UI under high DPI, ultrawide, HDR and various safe areas.
Defines UI QA standards for the studio. Implements visual regression testing pipeline, establishes accessibility compliance checklist per CVAA/EAA requirements.
Game QA
▼
Tests basic localization: checks translations in UI, finds untranslated strings, text overflow in interface elements. Tests on 2-3 languages using checklist.
Systematically tests localization: checks all languages (10+) for completeness, context accuracy, formatting (dates, numbers, currencies). Tests RTL languages (Arabic, Hebrew).
Designs localization QA strategy: automated string validation, pseudo-localization testing, cultural sensitivity review. Coordinates localization QA with external vendors.
Defines localization QA standards for the studio. Implements continuous localization testing, establishes quality metrics (LQA score), manages localization QA budget and timelines.
Git & Workflows
▼
Uses basic Git commands for working with test repositories: clone, pull, push, commit. Creates branches for test scripts, works with merge requests following team guidelines.
Applies advanced Git practices: rebase, cherry-pick, stash for managing test code. Resolves merge conflicts in test files, uses git bisect for finding regressions.
Manages Git strategy for QA repositories: branching model for tests, submodules for shared test utilities. Configures pre-commit hooks for test data validation.
Defines Git workflow for QA automation team. Implements mono-repo approach for test frameworks, establishes branching strategy synchronized with game development branches.
Pulls large test assets and build artifacts from Git LFS repositories. Understands why binary test recordings and reference screenshots are stored in LFS rather than standard Git. Follows team conventions for adding new QA assets to tracked patterns.
Configures Git LFS tracking patterns for QA-specific assets including test recordings, crash dumps, and reference screenshots. Manages LFS storage quotas for build artifacts and automates cleanup of obsolete test binaries. Sets up partial clone strategies to speed up QA environment provisioning.
Architects LFS storage strategies for QA pipelines handling terabytes of test recordings, performance captures, and build artifacts across multiple release branches. Implements automated LFS pruning policies that retain critical regression baselines while controlling storage costs. Designs CI/CD integration ensuring QA environments receive only necessary large assets.
Defines organizational LFS policies for QA asset versioning across multiple game projects and test environments. Coordinates storage budgets and retention rules for test recordings, automated capture artifacts, and performance baselines. Mentors QA engineers on effective LFS workflows and drives adoption of asset management best practices across QA teams.
GraphQL
▼
Understands GraphQL for game QA: tests GraphQL endpoints for game services, query validation. Uses GraphQL playground.
Tests game GraphQL: query complexity testing, mutation validation, subscription testing. Automates GraphQL API tests.
Designs GraphQL testing: comprehensive schema testing, performance benchmarks, security validation.
Defines GraphQL testing standards: schema validation requirements, performance testing, security policies.
Integration Testing
▼
Understands basics of integration testing for game subsystem interactions. Writes simple tests verifying asset loading, scene transitions, and server-client data synchronization. Follows team testing guidelines for game engine module integration validation.
Independently designs integration tests for game client-server synchronization and cross-system gameplay flows. Applies contract testing for matchmaking and leaderboard API boundaries. Integrates automated playtest scenarios into CI/CD build pipelines.
Designs integration testing strategy for multiplayer game systems spanning client, server, and third-party platform APIs. Implements automated testing across physics, networking, and rendering subsystems. Optimizes test pyramid balancing deterministic unit tests with non-deterministic gameplay integration tests. Mentors team on testing emergent gameplay behavior and platform certification requirements.
Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.
Kubernetes & Orchestration
▼
Understands Kubernetes for QA: tests containerized game services, verifies deployments. Uses kubectl for test verification.
Tests in Kubernetes: game service deployment validation, scaling testing, health check verification. Automates K8s testing.
Designs K8s testing strategy: container testing, service mesh validation, chaos testing for game services.
Defines K8s testing standards: deployment validation, scaling requirements, reliability testing policies.
Metrics & Monitoring
▼
Works with Prometheus/Grafana for QA: monitors game server metrics, tracks performance during tests.
Creates QA dashboards: game performance metrics, test execution monitoring, build quality tracking.
Designs QA monitoring: automated performance regression detection, test quality dashboards, game server health.
Defines QA monitoring standards: performance tracking requirements, quality dashboards, alerting policies.
Networking
▼
Understands networking for game QA: tests latency, packet loss simulation, network conditions. Uses network emulation tools.
Tests game networking: multiplayer connectivity, reconnection handling, bandwidth optimization. Simulates various network conditions.
Designs network testing: comprehensive network condition testing, geo-distributed testing, protocol validation.
Defines network testing standards: latency requirements, connectivity testing, network resilience policies.
OOP & Design Patterns
▼
Applies patterns in game QA: Page Object, Test Data Builder, Fixture patterns. Organizes test code using patterns.
Uses QA patterns: Strategy for multi-platform testing, Observer for event monitoring, Factory for test data generation.
Designs test architecture using patterns: extensible frameworks, plugin architectures, cross-game reusable patterns.
Defines QA design patterns: test framework patterns catalog, code review criteria, architectural guidelines.
Applies OOP in test automation: Page Object pattern, test class hierarchy, encapsulated test data. Organizes test code.
Uses OOP for test frameworks: abstract base test classes, strategy pattern for test scenarios, builder for test data.
Designs OOP-based test architecture: extensible test framework, plugin system, cross-platform test abstractions.
Defines OOP standards for QA: test code architecture, design patterns, code organization guidelines.
Performance Testing
▼
Runs basic load tests for game server using prepared scripts. Monitors response time and error rate during tests, records results in report.
Develops load test scenarios for game backend: login storms, matchmaking peaks, in-game economy spikes. Uses Gatling/k6/Locust for simulating 1000+ concurrent users.
Designs comprehensive load strategy: stress testing, soak testing, spike testing for game server. Models realistic player behavior patterns for launch day simulation.
Defines load testing standards for the studio. Implements continuous load testing in CI/CD, establishes performance baselines and SLAs for each game service.
Conducts basic performance testing: measures level load times, FPS in standard scenes, memory consumption. Records results in a table for comparison between builds.
Systematically tests performance: client profiling (CPU, GPU, memory), server response time, network latency. Uses built-in engine profilers and external tools.
Designs performance testing pipeline: automatic benchmarks, performance regression detection, reporting dashboards. Defines performance budgets for each target platform.
Defines performance testing strategy for the studio. Implements performance CI gates, builds performance QA team, defines escalation process for performance regressions.
Prompt Engineering
▼
Crafts basic prompts for AI tools in QA context: generating test cases, formulating bug reports, creating test data. Iteratively improves formulations.
Develops structured prompts for game QA tasks: few-shot examples for bug classification, chain-of-thought for crash log analysis. Uses system prompts for context.
Designs prompt pipelines for QA automation: automatic test case generation from game design docs, AI review of bug reports for completeness. Optimizes prompts by quality metrics.
Defines prompt engineering strategy for QA department. Builds prompt library for all QA processes, implements prompt versioning and A/B testing for optimization.
Relational Databases
▼
Works with PostgreSQL for QA: checks game data integrity, validates database states after tests. Writes SQL for test verification.
Tests game database: data consistency validation, migration testing, performance queries. Automates database assertions.
Designs database testing strategy: data integrity automation, performance testing, migration validation pipeline.
Defines database testing standards: mandatory data tests, migration review, performance requirements.
REST API
▼
Understands REST API for game QA: tests backend API of game services, verifies endpoints for leaderboards, inventory, matchmaking.
Tests game REST API: automates API testing for game backends, validates data contracts, tests error handling.
Designs API testing strategy: comprehensive game API coverage, load testing endpoints, security testing for game API.
Defines API testing standards: mandatory API tests, performance budgets for game endpoints, contract testing requirements.
Specialized Testing
▼
Understands basic accessibility testing concepts for games including colorblind modes, subtitle options, controller remapping, and input alternatives. Follows team checklists for verifying game accessibility features against platform certification requirements (Xbox, PlayStation, PC accessibility guidelines). Uses accessibility evaluation tools to test contrast ratios, font sizes, and audio cue alternatives in game UI elements.
Independently designs and executes accessibility test plans for games covering motor, visual, auditory, and cognitive accessibility dimensions. Tests game accessibility features including customizable controls, difficulty options, screen reader support for menus, and haptic feedback alternatives. Implements accessibility regression testing workflows ensuring updates don't break existing accessibility features across supported platforms.
Designs comprehensive game accessibility testing strategies covering CVAA compliance, platform-specific accessibility requirements, and inclusive design principles. Implements advanced testing patterns including assistive controller device testing, screen reader navigation for complex game UIs, and cognitive load assessment methodologies. Establishes accessibility testing with disabled gamers and advocacy groups to validate real-world usability beyond automated compliance checks.
Defines game accessibility testing standards and certification requirements across the organization's game portfolio. Establishes accessibility QA pipelines, disabled gamer testing programs, and platform compliance verification workflows for all game releases. Conducts architecture reviews ensuring game engines and frameworks support extensible accessibility features and mentors QA teams on inclusive game testing methodologies.
Understands the fundamentals of mobile game testing. Performs basic compatibility testing across devices and OS versions. Tests touch input, gestures, and game controls on mobile. Applies standard practices for identifying visual glitches and performance issues in daily work.
Independently develops mobile game test plans covering performance profiling, compatibility matrices, and touch input validation. Applies test design techniques for device-specific rendering and frame rate analysis. Integrates performance benchmarks and crash reporting into CI/CD pipelines.
Designs testing strategy for mobile games covering performance profiling, device compatibility, and input system validation across platforms. Implements automated testing for rendering, frame timing, and crash detection at all levels. Optimizes the test pyramid for rapid iteration cycles.
Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.
System Design
▼
Understands basic game system architecture: client-server model, game loop, main subsystems (rendering, physics, networking). Uses knowledge for more effective testing.
Applies system design knowledge for testing: understands ECS, event systems, state machines in game logic context. Tests subsystem interactions and edge cases.
Uses system design knowledge for designing test strategies. Analyzes architecture to identify risk areas, designs integration tests for interconnected subsystems.
Defines approaches to architecture-aware testing for QA team. Establishes guidelines for testing various architectural patterns: ECS, microservices, event-driven.
Technical Documentation
▼
Understands the basics of runbook writing for QA incident triage and escalation. Follows existing playbooks for crash reproduction, test environment recovery, and build validation failures. Documents encountered issues according to runbook templates.
Independently writes runbooks for game QA processes: certification submission checklists, platform-specific compliance verification, live-ops incident triage procedures. Understands trade-offs between rigid step-by-step playbooks and adaptive QA workflows.
Designs runbook architecture for game QA operations across multiple titles and platforms: live service incident response, multiplayer issue escalation, platform certification failure recovery. Mentors QA team on writing maintainable playbooks that adapt to rapid release cycles.
Defines Runbook and Playbook Writing strategy at team/product level. Establishes standards and best practices. Conducts reviews.
Test Infrastructure
▼
Runs existing game automated tests by following instructions. Understands test framework structure, reads logs and reports, reports failures with steps and context.
Writes automated tests for game systems: UI automation via Airtest/Appium, API tests for backend. Maintains test framework: updates locators, fixes flaky tests.
Designs automation framework for game project: selects tools (Airtest, GameDriver, AltTester), integrates with CI/CD. Automates smoke testing and certification checks.
Defines automation strategy for studio QA department. Builds custom framework for cross-platform automation, implements visual testing and AI-based object recognition.
Understands basic principles of test data management for game testing. Creates simple test datasets for gameplay scenarios. Follows team guidelines for managing test accounts, save files, and in-game assets used during verification.
Independently designs test data strategies for complex game testing scenarios including multiplayer sessions and progression systems. Builds reusable data generators for game states. Manages test data versioning aligned with game build pipelines.
Designs enterprise-level test data strategies for large-scale game projects with multiple platforms. Implements synthetic data generation for rare game events and complex player behavior patterns. Establishes team-wide standards for test data governance and mentors QA engineers.
Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.
Understands basics of test environment setup for game testing. Configures local test builds and dev kits following team instructions. Follows documented procedures for deploying game builds to test consoles and managing environment prerequisites.
Independently manages test environments for multi-platform game testing including console dev kits, mobile devices, and PC configurations. Automates environment provisioning for nightly build verification. Troubleshoots environment-specific issues affecting test reliability.
Designs scalable test environment architecture for AAA game projects spanning multiple platforms and regions. Implements cloud-based environment provisioning for distributed QA teams. Establishes standards for environment parity with production. Mentors team on environment management best practices.
Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.
Test Strategy
▼
Understands TDD/BDD fundamentals for game testing: writing test scenarios in Given/When/Then format, basic unit test concepts for game logic, and test-first approach for deterministic game systems. Follows team guidelines for BDD scenarios in gameplay feature testing.
Applies TDD/BDD for game feature testing: writes comprehensive BDD scenarios for gameplay mechanics, implements automated tests for game balance and progression systems, and uses property-based testing for randomized game elements. Integrates BDD scenarios with game CI pipelines. Covers edge cases in multiplayer interactions and state transitions.
Designs testing strategy for game projects using TDD/BDD: automated test pyramids for game systems, BDD-driven acceptance testing for game features, and property-based testing for procedural content. Implements testing infrastructure for multiplayer simulation and load testing. Optimizes test execution for fast feedback in game CI. Mentors team on test-driven game development practices.
Defines testing strategy at product level. Establishes quality assurance standards. Implements shift-left testing culture.
Writes basic test cases for game mechanics using template: preconditions, steps, expected result. Covers main positive scenarios for key level features.
Develops test cases applying boundary values, equivalence partitioning for game parameters (health, damage, speed). Creates checklists for regression testing.
Designs test cases for complex game systems: economy, progression, multiplayer. Applies pairwise testing for combinatorial testing of graphics settings and platforms.
Defines test design standards for QA department. Implements model-based testing for game states, establishes approaches for testing procedurally generated content.
Creates basic test plan for individual game feature: scope, test case list, test environment. Estimates effort for simple tasks under lead guidance.
Develops test plans for milestone builds: defines scope, risk areas, test environment matrix. Plans regression cycles and distributes tasks among testers.
Designs comprehensive test plan for full release cycle of AAA title. Includes certification testing (TRC/TCR/Lotcheck), compatibility matrix, localization QA and performance targets.
Defines test planning strategy for the studio. Establishes plan templates, implements metrics-driven approach to release readiness assessment (release readiness criteria).
Unit Testing
▼
Understands unit testing principles and reads existing tests in game codebase. Writes simple unit tests for test utilities and helper functions in QA framework.
Develops unit tests for test libraries and automation utilities. Applies mocking for test isolation, uses NUnit/xUnit for Unity or GoogleTest for C++ projects.
Designs unit test strategy for QA infrastructure: covering test frameworks, CI plugins, reporting tools. Implements TDD for developing critical test components.
Defines unit testing standards for QA automation code. Establishes coverage targets, implements mutation testing for test quality assessment, trains team in TDD practices.
Understands basic unit testing concepts for game QA: test case structure for game mechanics, reproducible bug verification tests, gameplay scenario assertions. Follows team practices for automated smoke tests and regression test organization.
Independently writes unit tests for game systems: automated test cases for game mechanics, reproducible test scenarios for physics/AI behavior, regression tests for balance changes. Integrates game tests into CI/CD and covers edge cases for multiplayer state synchronization.
Designs testing strategy for game projects: automated test pyramid for game mechanics/physics/AI, performance regression testing for frame budgets, deterministic replay testing for multiplayer. Optimizes game test execution with headless server builds. Mentors team on automated game testing best practices.
Defines testing strategy at product level for game projects: automated gameplay test standards, performance regression testing governance, multiplayer testing frameworks. Establishes shift-left testing culture with automated quality gates for game builds and content updates.