Grade Calculator — DevLevelUp

Select a role to assess

Rate your skill proficiency — the system will calculate your recommended grade

Role

Skills Self-Assessment

Role: Game Designer

Assessed: 0 Total: 0

Game Design 5

▼

Designs basic economic systems: currencies, resources, shop, level rewards. Creates simple balance tables in Google Sheets with progression formulas. Understands sink/source concepts, inflation, and resource deficit in game economies.

Develops in-game economy systems: resource balance, sink/source models, progression curves. Models economy in spreadsheets with player behavior simulation. Conducts A/B tests of monetization mechanics. Balances reward schedules for optimal engagement.

Defines the game's economic strategy: monetization model, pricing strategy, economy health KPIs. Establishes economy balancing process: data analysis → hypothesis → A/B test → rollout. Mentors the team in economic modeling and exploit prevention.

Shapes enterprise game economy strategy for the project portfolio. Defines best monetization practices, cross-game economy patterns, ethical monetization guidelines. Evaluates new models: battle pass economics, dynamic pricing, player-driven economies.

Designs basic game mechanics: movement systems, interactions, character progression. Creates game design documents (GDD) describing the core loop. Tests mechanics in Unity/Unreal prototypes and iterates based on playtest feedback.

Designs complex game systems: combat system, crafting, skill trees, quest systems. Balances mechanics through spreadsheet modeling and playtesting. Creates secondary loops and meta-game. Understands player psychology and applies motivational frameworks (SDT, Bartle taxonomy).

Defines the mechanical vision of the game project: core pillars, experience goals, design principles. Establishes prototyping and mechanic validation process. Reviews team design decisions for vision alignment. Mentors designers in creating elegant game mechanics.

Shapes game design philosophy at the studio level. Defines innovative mechanics for product differentiation. Evaluates game design trends and defines R&D directions. Creates reusable game design frameworks for the project portfolio.

Creates basic narrative elements: quest descriptions, NPC dialogues, lore entries, item descriptions. Understands game narrative structure: main story, side quests, environmental storytelling. Writes tutorial and onboarding text with player guidance in mind.

Designs narrative systems: branching dialogues, player choice consequences, narrative pacing. Creates compelling characters with character arcs. Uses narrative tools (Ink, Twine, Yarn Spinner) for implementing branching stories. Integrates narrative with gameplay mechanics.

Defines narrative vision for the project: tone, themes, storytelling methods. Builds narrative team and processes: from concept to implementation. Coordinates narrative with game design, art, and audio for a cohesive experience. Mentors narrative designers.

Shapes narrative philosophy at the studio level: storytelling identity, IP development strategy, transmedia approaches. Defines innovative narrative technologies: AI-driven dialogue, procedural storytelling, interactive fiction. Creates IP expandable across multiple media.

Understands core game UX principles: player feedback loops, input responsiveness, and HUD readability. Creates basic UI mockups and wireframes following established design patterns. Follows team standards for menu flow, tutorial design, and accessibility considerations in game interfaces.

Designs comprehensive UX systems: onboarding flow, control schemes for different platforms, accessibility features. Creates UI/UX documentation with wireframes and interaction specifications. Conducts usability testing and analyzes interaction heatmaps. Ensures consistent UX language.

Defines UX vision for the game project: experience principles, interaction model, accessibility goals. Builds UX team and processes. Coordinates UX with game design and art direction. Mentors designers in user-centered game design and conducts design critiques.

Shapes UX philosophy at the studio level: UX standards, accessibility commitment, user research methodology. Defines innovative UX approaches: adaptive UI, context-aware interfaces, haptic feedback design. Creates UX culture and design system for the project portfolio.

Creates basic levels: graybox blockouts, simple layouts considering player flow. Understands level design principles: leading lines, landmarks, pacing. Uses editor tools (Unity ProBuilder, Unreal BSP) for rapid prototyping. Tests levels and iterates.

Designs complex levels: multi-path layouts, vertical gameplay, risk/reward zones. Creates encounter design: enemy placement, cover systems, difficulty pacing. Works with navigation meshes for AI. Balances levels through playtesting: timing, challenge, reward distribution.

Defines level design vision for the project: world structure, biome diversity, progression through world. Builds level design team and pipeline. Reviews layout and encounter design. Mentors level designers. Coordinates level design with narrative and art direction.

Shapes level design philosophy at the studio level: design principles, quality benchmarks, innovation directions. Defines procedural generation strategy for content scaling. Evaluates new approaches: AI-assisted level design, player-generated content, infinite worlds.

Game Engines 1

▼

Uses Unity Editor for prototyping game mechanics: creating scenes, configuring components, basic C# scripting. Works with Inspector to configure game object parameters. Creates simple prototypes to test design ideas without programmer assistance.

Confidently works in Unity for game design tasks: ScriptableObjects for data-driven design, Prefab workflow, Animation Controller. Creates gameplay prototypes with UI, animations, basic AI. Uses Unity Tools: Tilemap, Cinemachine, Timeline for game content creation.

Defines Unity workflow strategy for the game design team: project structure, asset pipeline, tool requirements. Establishes best practices for Unity usage by designers. Coordinates with engineering to create design-friendly tools. Evaluates Unity capabilities for the project.

Shapes enterprise Unity strategy for the studio: versioning, licensing, technology roadmap. Evaluates Unity DOTS, ECS for performance-critical systems. Defines Unity vs Unreal choices for different projects. Coordinates with Unity Technologies at the enterprise level.

Game Infrastructure 3

▼

Understands basic game analytics metrics: DAU, MAU, retention D1/D7/D30, session length. Sets up simple analytics events in the game: level_start, level_complete, purchase. Reads basic reports and dashboards to evaluate player behavior.

Designs analytics event system for full game system coverage. Analyzes funnel metrics, level heatmaps, player resource distribution. Conducts A/B tests of balance changes and interprets results. Uses cohort analysis to evaluate changes.

Defines analytics strategy for the game project: success metrics, KPI framework, data governance. Builds a data-driven decision-making culture in the game design team. Coordinates analyst and designer work to optimize player experience.

Shapes enterprise game analytics strategy for the studio's project portfolio. Defines unified analytics platform, cross-game data sharing, portfolio-level KPIs. Implements advanced analytics: causal inference, ML-driven optimization, player modeling.

Understands main monetization models: F2P, premium, subscription, ads. Designs simple IAP offers: cosmetics, boosters, starter packs. Knows monetization metrics: ARPDAU, ARPPU, conversion rate. Studies competitor monetization for benchmarking.

Designs monetization: IAP catalog, rewarded ads integration, battle pass, subscription model. Creates dynamic offers based on player behavior. Balances monetization for optimal LTV without harming retention. Conducts A/B tests of pricing and offer design.

Defines monetization strategy for the game project: revenue model, pricing, target KPIs. Establishes the process: hypothesis → A/B test → analysis → rollout. Coordinates monetization with game design to preserve player experience. Forecasts revenue and reports to stakeholders.

Shapes enterprise monetization strategy for the project portfolio. Defines ethical monetization standards for the studio. Evaluates new models: play-to-earn, subscription bundles, cross-game economies. Influences industry ethical monetization standards.

Understands LiveOps fundamentals: seasonal events, battle passes, and daily challenges. Assists in designing content calendars and player engagement loops. Analyzes basic retention metrics.

Designs live-ops pipeline: event calendar, content cadence, event templates. Creates diverse events: competitive leaderboards, collection events, co-op challenges. Analyzes event metrics and optimizes engagement. Works with remote config for server-side changes.

Defines live-ops strategy for the game: content cadence, monetization rhythm, seasonal structure. Builds team and processes for sustainable live-ops. Coordinates live-ops with development roadmap and marketing. Builds revenue forecasts from events.

Shapes enterprise live-ops strategy for the game portfolio. Defines shared live-ops infrastructure, cross-game events, unified content calendar. Evaluates new live-ops models: user-generated content, community-driven events, AI-personalized experience.

Game Platforms 2

▼

Understands mobile game design specifics: touch controls, portrait/landscape, session length, device limitations. Designs mechanics for mobile constraints: simple tap/swipe, auto-play, offline progress. Knows mobile-specific metrics: install rate, ARPDAU, CPI.

Designs mobile-first game systems: session design for 3-5 minute gameplay, energy systems, push notifications, social features. Optimizes UX for mobile: onboarding flow, store placement, FTUE. Creates monetization design for mobile: IAP, ads, battle pass.

Defines mobile game strategy for the studio: target genres, target markets, platform-specific features. Establishes mobile game design process and team. Coordinates with UA and marketing to optimize game design for acquisition. Defines quality standards for mobile.

Shapes enterprise mobile gaming strategy: portfolio strategy, cross-platform approach, emerging mobile platforms. Evaluates new mobile trends: cloud gaming, AR mobile, cross-play. Defines innovation directions for mobile game design.

Understands PC/console game design specifics: controller input, wide-screen UI, long sessions, premium expectations. Designs mechanics for gamepad: button mapping, analog stick controls, trigger usage. Considers platform-specific features: achievements, leaderboards, cloud saves.

Designs PC/console-specific game systems: deep progression, complex inventory, controller + keyboard/mouse support. Creates content for long sessions: 20+ hour campaigns. Optimizes UX for living room experience: couch co-op, split screen, big picture mode.

Defines PC/console game strategy: target platforms, exclusive deals, launch strategy. Builds team and process for premium game development. Coordinates with platform holders (Sony, Microsoft, Nintendo). Defines quality bar for premium product.

Shapes enterprise PC/console strategy for the studio: platform partnerships, next-gen capabilities, distribution strategy. Evaluates emerging platforms and business models. Defines technology investments for premium game development.

Game Programming 4

▼

Designs basic NPC behavior: patrolling, chasing, attacking. Uses finite state machines to describe AI logic in GDD. Tests AI behavior in Unity/Unreal prototypes and iterates parameters to improve player experience.

Designs AI systems based on behavior trees: tactical behavior, team coordination, adaptation to player actions. Configures NavMesh for complex levels with dynamic obstacles. Balances AI difficulty for different difficulty levels through parametric tuning.

Defines AI strategy for the game project: approach selection (FSM, BT, Utility, GOAP), behavior design standards, tools pipeline for designers. Establishes best practices for creating convincing AI and mentors the team. Ensures AI system scalability.

Shapes the vision for AI usage in games at the studio level: ML-driven NPC behavior, procedural storytelling, emergent gameplay. Evaluates new AI technologies (LLM-powered NPCs, neural behavior) for future projects. Defines R&D directions for AI in game design.

Understands game animation fundamentals: sprite sheets, skeletal animation, and state machine basics. Creates simple animation specifications and references for the art team. Follows established animation guidelines for character states, transitions, and timing in game design documents.

Designs animation state machines for complex characters: combo systems, blend trees, animation layers. Configures animation events synchronized with gameplay (hitbox timing, VFX triggers). Works with root motion and animation curves for physically correct movement.

Defines animation strategy for the game project: stylistics, technical pipeline, quality bar. Coordinates animator and designer work to achieve target game feel. Creates reusable animation assets and tools to accelerate development.

Shapes animation vision at the studio level: technology standards, pipeline automation, motion capture strategy. Evaluates new technologies: ML-driven animation, neural motion synthesis. Defines animation R&D directions for future projects.

Understands the role of sound in creating game feel and player experience. Describes audio requirements in GDD: sound effects, ambient, musical themes. Sets up basic audio systems in Unity/Unreal: triggers, volume control, spatial audio for 3D environments.

Designs sound design for game systems: adaptive music, dynamic mixing, procedural audio triggers. Works with FMOD/Wwise to create interactive soundscapes. Configures audio layers for different gameplay states: exploration, combat, cutscene.

Defines audio strategy for the project: middleware selection (FMOD/Wwise), pipeline from recording to integration, quality standards. Coordinates sound designer and game designer work to create immersive audio experience. Establishes audio style guide for the studio.

Shapes sound design vision at the studio level: technology strategy, audio tool investments, R&D directions. Evaluates new technologies: spatial audio for VR, AI-generated music, haptic feedback integration. Defines the studio's audio identity.

Understands basic physics systems in games: collision detection, rigidbody, triggers, raycasting. Configures physical parameters for proper game feel: gravity, friction, bounciness. Tests physics in prototypes and iterates for comfortable controls.

Designs physics systems for gameplay: ragdoll, destruction, vehicle physics, cloth simulation. Configures physics layers and collision matrix for optimization. Creates custom physics for game feel: tweaked gravity curves, coyote time, input buffering for responsive controls.

Defines physics strategy for the project: physics engine selection, custom vs built-in, simulation fidelity. Establishes physics design guidelines for designers. Coordinates with programmers to achieve target game feel. Mentors the team in physics-based game design.

Shapes physics vision at the studio level: technology investments, R&D directions, physics-based gameplay innovation. Evaluates new technologies: ML-driven physics, position-based dynamics. Defines physics capabilities for next-generation projects.

Game QA 2

▼

Understands basic game performance concepts: FPS, draw calls, memory usage, CPU/GPU bottleneck. Profiles simple scenes in Unity Profiler/Unreal Insights. Considers performance when designing levels: object count, particle effects, lighting.

Profiles and optimizes game scenes: LOD setup, occlusion culling, texture streaming, object pooling. Sets performance budgets for levels and systems. Understands trade-offs between visual quality and performance. Optimizes game systems for target hardware.

Defines performance strategy for the project: target platforms, quality tiers, optimization pipeline. Builds performance culture in the team: budgets, profiling practices, automated tests. Coordinates designer and programmer work to achieve performance targets.

Shapes enterprise performance strategy for the studio: shared optimization tools, performance benchmarks, scalability patterns. Evaluates new technologies: Nanite, Lumen, mesh shaders for future projects. Defines technical constraints for game design at the studio level.

Conducts playtesting of basic mechanics: checks game feel, balance, found bugs. Creates bug reports with clear reproduction steps and expected/actual behavior. Participates in QA process: smoke testing new builds, regression testing after fixes.

Designs and conducts structured playtests: usability testing, balance testing, difficulty curve evaluation. Creates test plans for game systems. Analyzes playtest data (video recordings, metrics, questionnaires) and formulates actionable improvements. Automates basic balance testing.

Defines QA strategy for the project: testing pyramid, quality gates, release criteria. Builds QA team and processes. Coordinates internal and external playtesting. Creates a culture of quality in the game design team. Defines quality metrics and acceptance criteria.

Shapes enterprise QA strategy for the project portfolio. Defines shared testing infrastructure, quality standards, playtesting methodologies. Evaluates new approaches: AI-driven QA, procedural test generation, crowd-testing platforms for massive coverage.

Technical Documentation 1

▼

Documents simple game systems: describes mechanic parameters, balance tables, interaction rules. Creates basic Game Design Documents (GDD) with core loop and main feature descriptions. Uses templates for structuring documentation.

Creates detailed technical documentation for game systems: event API descriptions, balance data structures, client-server interaction protocols. Writes specifications for external SDK integration (analytics, monetization). Documents configuration parameters for live-ops.

Defines documentation standards for game systems across the entire studio. Establishes templates for GDD, technical specifications, balance sheets. Implements documentation review processes and knowledge sharing between teams. Ensures documentation stays current throughout the project lifecycle.

Shapes documentation culture at the organizational level. Defines enterprise documentation standards for the game project portfolio. Evaluates and implements documentation automation tools: Confluence, Notion, custom wiki. Creates methodology for knowledge transfer between studio projects.

Additional skills (optional) 27

These skills do not affect the main grade but show the breadth of your profile.

AI Coding Assistants

▼

Uses ChatGPT/Claude to generate content ideas: item descriptions, NPC dialogues, lore. Can formulate prompts for quality game text and narrative. Understands AI assistant limitations and reviews generated content for quality.

Applies AI assistants for prototyping game mechanics, balancing, and generating test data. Creates complex prompt chains to automate routine game design tasks: balance tables, loot tables. Integrates AI tools into the game content creation pipeline.

Defines AI assistant usage strategy for the game project to accelerate development. Standardizes LLM practices for the entire team: prompt templates, review processes. Evaluates risks and opportunities of AI-generated content for commercial game products.

Uses GitHub Copilot to speed up writing simple scripts: game events, config parsers, utility functions. Understands AI generation limitations for game-specific code. Checks suggestions for correctness regarding game logic and balance parameters.

Effectively uses Copilot for game design tasks: generating config files, balance formulas, test scripts. Writes quality prompts for game-specific code. Understands when Copilot is useful (boilerplate, formulas) and when manual approach is needed (core mechanics logic).

Defines AI-assisted game development strategy for the team. Establishes best practices for Copilot and other AI tool usage. Evaluates AI tool impact on game design team productivity. Trains designers on effective AI assistant usage.

Algorithms & Data Structures

▼

Understands basic search and sorting algorithms for game system applications. Knows the Big-O concept and can evaluate performance of simple game loops. Uses knowledge to optimize iterations over game object collections.

Applies graph algorithms for pathfinding (A*, Dijkstra) when designing levels. Evaluates game system complexity: matchmaking, procedural generation, AI decision trees. Selects appropriate algorithms for load balancing in real-time games.

Defines algorithmic optimization standards for the game project. Reviews team architectural decisions for computational complexity. Establishes performance budgets for each game subsystem and trains designers on evaluating algorithmic cost of solutions.

Understands basic data structures and their application in game systems: arrays for inventory, dictionaries for object parameters, trees for dialogues. Selects appropriate structures for storing game data in ScriptableObjects and config files.

Designs data structures for game systems: graphs for NPC navigation, decision trees for AI, priority queues for event systems. Optimizes balance data access for runtime performance. Creates efficient data schemas for game config.

Defines game data organization standards for the project: data schemas, naming conventions, serialization formats. Reviews data structure choices for critical systems. Trains the designer team on effective data structure usage when designing mechanics.

Application Security

▼

Knows main OWASP vulnerabilities and their applicability to game servers and services. Understands basic security principles: input validation, injection protection in game APIs. Recognizes the importance of protecting player data: accounts, payment information, progress.

Applies OWASP Top 10 when designing game servers and APIs: protection against XSS, CSRF, SQL injection. Implements secure player authentication and protection against game data manipulation. Conducts basic security review of game endpoints and client-server protocol.

Defines security strategy for the entire game project: servers, clients, infrastructure. Standardizes security practices across the team and conducts regular architecture security reviews. Coordinates with the security team and manages the vulnerability disclosure process.

CI/CD

▼

Understands basic CI/CD concepts and the purpose of GitHub Actions for automating game project builds. Can read pipeline YAML configurations and understands workflow triggers. Can run an existing pipeline for building a test game version.

Configures GitHub Actions for automatic building and testing of game projects across platforms. Sets up build matrices for cross-platform builds: PC, consoles, mobile. Integrates automated code quality checks and tests into the PR process.

Defines CI/CD strategy for all game project repositories and supporting tools. Standardizes GitHub Actions workflows for the team: templates, reusable actions, secrets. Ensures pipeline reliability and speed as the team scales.

Clean Code & Refactoring

▼

Understands clean code principles when writing game scripts in Unity/Unreal. Follows naming conventions for game objects, prefabs, balance variables. Uses comments to explain game mechanic logic in Blueprint/C# scripts.

Applies design patterns in game scripts: State Machine for AI, Observer for events, Strategy for enemy behavior. Structures game config files for convenient balancing. Refactors mechanic prototypes to production quality.

Defines code and configuration quality standards for the game project. Establishes coding guidelines for game designers working with Blueprint/Visual Scripting. Implements automated testing for game systems and code review process for design scripts.

Cloud Providers

▼

Understands basic AWS services for game server hosting: EC2, S3, RDS. Knows cloud infrastructure concepts and their application for game backend: data storage, CDN, compute. Can deploy a simple game server on EC2 following instructions.

Uses AWS services for game infrastructure: GameLift, DynamoDB, CloudFront for asset delivery. Configures auto-scaling for game servers during peak loads and global launches. Sets up S3 + CloudFront for efficient game content delivery across regions.

Defines cloud strategy for the entire game project: architecture, budget, scaling. Standardizes AWS practices across the team: IaC, security groups, cost optimization for game workloads. Coordinates with AWS team for game infrastructure optimization.

Code Review

▼

Participates in game mechanic script reviews under mentor guidance. Checks correctness of balance parameters in config files. Reads other designers' Blueprint/Visual Scripting and asks questions about mechanic logic.

Conducts reviews of game scripts and configs: checks balance parameters, mechanic logic, state machine correctness. Identifies potential exploits and edge cases in game systems. Provides constructive feedback on game design decision implementation.

Defines code review process for the game design team: checklists for balance configs, guidelines for mechanic scripts. Conducts architectural reviews of key game systems. Mentors designers in conducting quality reviews.

Concurrency & Parallelism

▼

Understands asynchronous programming concepts and callbacks in the context of loading game resources. Knows basic async/await patterns for working with server APIs and saving progress. Can write simple async code for loading data from backend.

Implements asynchronous content loading and asset streaming in game engines. Manages parallel network requests for multiplayer systems with proper error handling. Optimizes async operations to minimize freezes in the game loop.

Defines asynchronous programming standards for the game project and a library of common patterns. Reviews team async system architecture for race conditions and deadlocks. Trains developers on safe async/await usage in real-time context.

Containerization

▼

Knows basic Docker commands for running game servers in containers. Can use docker-compose for local development environment deployment. Understands the containerization concept and its benefits for reproducible game build environments.

Creates Dockerfiles for building and deploying game servers and tools. Configures multi-stage builds to optimize server component image sizes. Sets up docker-compose environments for local multiplayer scenario testing.

Defines containerization strategy for all game project services. Standardizes Docker practices for the team: base images, security policies, monitoring. Trains the team on effective container usage for game development and testing.

Docs-as-Code

▼

Creates simple game system diagrams: core loop flowcharts, mechanic interaction schemas, game content mind maps. Uses Miro, draw.io, or Figma to visualize game design ideas. Understands basic notations for describing game flows.

Creates detailed game system diagrams: state machines for AI behavior, progression flow diagrams, economic cycle schemas (sink/source). Visualizes dependencies between game systems. Uses UML to describe complex interactions.

Defines visual documentation standards for the game design team. Builds a diagram template library: economy flows, system architectures, player journey maps. Trains the team on effective visual communication of game design decisions.

Shapes visual communication culture at the studio level. Creates methodology for documenting complex game systems through diagrams. Defines enterprise tools and standards for game design visualization across multiple projects.

Game Engines

▼

Uses Unreal Editor for prototyping: BSP modeling, Blueprint visual scripting, basic Actor setup. Creates simple levels and game mechanics prototypes in Blueprint. Works with Level Editor for blockout and playtesting design ideas.

Confidently works with Unreal for game design: Blueprint for complex mechanics, Sequencer for cutscenes, World Partition for open world. Creates gameplay systems via Blueprint: AI behavior trees, UI widgets, interaction systems. Uses Data Tables for data-driven design.

Defines Unreal workflow strategy for the game design team. Establishes Blueprint coding standards and best practices. Coordinates with C++ engineers to create designer-friendly systems. Evaluates Unreal features for the project: Nanite, Lumen, MetaHuman.

Shapes enterprise Unreal strategy for the studio: licensing, custom engine modifications, technology pipeline. Evaluates Unreal 5+ features for future projects. Defines engine choices for different project types. Coordinates with Epic Games at the enterprise level.

Game Platforms

▼

Understands web game design specifics: browser limitations, load time, casual audience. Designs mechanics for web: simple input, quick onboarding, shareable gameplay. Knows web-specific technologies: HTML5 Canvas, WebGL, Web Audio API and their game design limitations.

Designs web-first game systems: instant play, cross-device experience, social sharing mechanics. Creates game design for web platforms: Facebook Instant Games, itch.io, CrazyGames. Optimizes UX for web: loading experience, responsive layout, keyboard/mouse + touch.

Defines web game strategy for the studio: target platforms, technology stack, market positioning. Builds web game development team and process. Coordinates with web platform partners for distribution. Defines quality standards for web game production.

Game QA

▼

Understands game localization basics: text externalization, string tables, and locale-aware UI layout considerations. Prepares content for localization by using placeholder-based dialogue systems and avoiding hardcoded strings. Follows team guidelines for writing localizable game text and cultural notes.

Designs localization system for the game project: string management, dynamic text, localization-friendly UI. Works with translation agencies: preparing lockits, context documents, voice-over scripts. Ensures culturalization — content adaptation for different markets.

Defines localization strategy for the game project: target markets, languages, budget, timelines. Builds localization team and processes. Coordinates with external partners. Ensures quality standards through LQA metrics and vendor management.

Git & Workflows

▼

Uses Git for versioning game design files: GDD, balance configs, mechanic scripts. Performs basic operations: commit, push, pull, creating branches. Understands the importance of version control for game design team collaboration.

Applies Git branching strategies for game design workflow: feature branches for new systems, release branches for builds. Resolves merge conflicts in config files. Uses Git LFS for storing large game assets. Works with Pull Requests for design change reviews.

Defines version control standards for the studio: Git conventions, branching policies, code review process. Establishes best practices for game design files in version control. Trains the team on effective Git usage in game development context.

Integration Testing

▼

Understands the difference between unit and integration testing in game system context. Can run existing integration tests to verify game subsystem interactions. Knows basics of client-server interaction testing in multiplayer games.

Writes integration tests for verifying game system interactions: inventory-economy, AI-navigation. Sets up test environments for multiplayer scenario testing with network condition emulation. Tests game service integration: authentication, payments, analytics.

Defines integration testing strategy for the entire game project and CI/CD pipeline. Standardizes approaches to testing interactions between teams: client, server, infrastructure. Implements quality metrics and release readiness criteria for each release.

Logging

▼

Understands the importance of logging for debugging game systems and knows basic log levels. Can add structured logs to game code for tracking events: connections, errors, states. Reads logs to diagnose simple issues in test sessions.

Implements structured logging in game servers with JSON format and correlation IDs. Configures logging levels for different subsystems: gameplay, network, AI, rendering. Uses logs for player behavior analysis and multiplayer network issue diagnosis.

Defines observability strategy for the game project: logs, metrics, traces. Standardizes logging format and policies for all project teams. Builds a data-driven debugging culture through structured game event log analysis.

Metrics & Monitoring

▼

Understands basic Prometheus & Grafana for game metrics: reading player analytics dashboards, understanding gameplay metrics (session duration, retention), navigating Grafana panels for game economy and balance data. Follows team conventions for monitoring game KPIs.

Configures Prometheus for collecting game server metrics: TPS, matchmaking time, player sessions. Creates Grafana dashboards for monitoring game subsystem performance and health. Sets up alerts for critical game metrics: crash rate, queue length, server lag.

Defines monitoring and observability strategy for the entire game project. Standardizes metrics and dashboards for all teams: gameplay, infra, analytics, QA. Builds a data-driven operations culture through game system monitoring and alerting.

Shapes corporate monitoring strategy for the studio's game product lineup. Defines unified observability platform architecture for all projects. Researches and implements advanced monitoring approaches: AIOps, predictive alerting for live-service games.

OOP & Design Patterns

▼

Knows basic design patterns: Singleton, Observer, Factory in the context of game systems. Understands pattern applications for organizing game code: scene managers, object pools. Can recognize typical patterns in game engine codebase.

Applies game design patterns: State Machine, Command, Strategy for AI and gameplay. Uses Component/ECS for flexible game entity architecture and modularity. Combines patterns for specific tasks: quest system, dialogue trees, combat system.

Defines the architectural style and standard pattern set for the game project codebase. Reviews team architectural decisions and recommends optimal patterns for each subsystem. Conducts architecture sessions and trains the team on applying patterns in game development.

Understands basic OOP principles: encapsulation, inheritance, and polymorphism in the context of game objects. Can create simple class hierarchies for game entities: characters, items, abilities. Reads and understands object-oriented game system code.

Applies SOLID principles when designing game systems: inventory, combat system, AI. Chooses between inheritance and composition for modeling game entities and behaviors. Designs extensible systems using interfaces and abstract classes.

Defines OOP design architectural standards for the entire game project codebase. Reviews team class hierarchies for SOLID compliance and game patterns. Trains developers on proper OOP application in the context of high-performance games.

Relational Databases

▼

Understands basic PostgreSQL concepts for game design: how game data (items, quests, progression) is stored in relational tables, basic queries for game balance data analysis, understanding data schemas for level and content design. Follows team conventions for game data documentation.

Designs PostgreSQL schemas for game data: player profiles, economy, leaderboards, statistics. Optimizes queries using indexes and EXPLAIN for high-load game tables. Uses transactions and JSONB for flexible game content and configuration storage.

Defines PostgreSQL usage strategy for the game project: sharding, backups, DR. Standardizes database practices for the team: migrations, naming conventions, performance review. Coordinates database scaling for growing game audience.

Shapes corporate PostgreSQL strategy for the studio's game product lineup. Defines data storage architectural patterns for large-scale online games. Publishes best practices and influences PostgreSQL tool development for gaming workloads.

REST API

▼

Understands basic REST API principles and HTTP methods in the context of game servers. Knows the difference between GET/POST/PUT/DELETE and can read server API documentation for game system integration. Can describe simple endpoints for saving player progress.

Designs REST APIs for game services: leaderboards, inventory, matchmaking. Considers API versioning during client updates and backward compatibility. Defines endpoint structure for live-service games accounting for mobile client limitations.

Defines API strategy for the entire game project, including public APIs for mods and UGC. Standardizes interface design approaches between game subsystems. Reviews team API contracts and ensures documentation consistency.

System Design

▼

Understands basic system design concepts: client-server, databases, caching in the gaming context. Knows main online game architecture components: game server, matchmaking, persistence layer. Can describe a simple casual mobile game architecture.

Designs game subsystem architecture: lobby, party system, chat, leaderboard with scaling considerations. Evaluates trade-offs in architectural decisions: latency vs consistency, cost vs performance. Develops system design for medium-scale multiplayer games.

Defines system architecture for the entire game project and coordinates technical vision across teams. Conducts design reviews and makes key architectural decisions considering business requirements. Mentors senior engineers in game platform system design skills.

Unit Testing

▼

Understands basic testing for game design assets: balance formula verification, progression curve validation, probability distribution checks for loot tables. Follows team practices for documenting expected outcomes and validating game mechanic calculations.

Writes unit tests for complex game systems: balance, economy, AI behavior. Uses mocks and stubs to isolate tested components from engine and server. Maintains test coverage for critical game mechanics with each release.

Defines testing strategy for the entire game project: unit, integration, playtest. Standardizes game system testing approaches across the team and establishes coverage metrics. Implements TDD culture for critical gameplay subsystems.

User Documentation

▼

Documents knowledge about game systems in wiki/Confluence: mechanic descriptions, balance rules, design decisions. Creates structured entries about game design decisions with rationale. Uses templates for standardizing the knowledge base.

Creates a structured knowledge base for the game design team: design patterns, balance formulas, postmortem insights. Organizes knowledge sharing: design reviews, brown bag sessions, retrospectives. Ensures searchability and documentation currency.

Defines knowledge management strategy for the game design team. Establishes documentation processes: GDD templates, balance decision logs, design rationale. Ensures knowledge transfer during new designer onboarding and between projects.

Creates user documentation for the game: tutorial texts, help screens, FAQ, mechanic descriptions for players. Writes clear instructions: how-to guides, control references. Considers different player skill levels when writing help content.

Designs in-game documentation system: contextual help, tooltips, codex/bestiary, tutorial system. Creates player-facing documentation for community: patch notes, dev blogs, game guides. Writes user documentation considering player journey and discovery.

Defines documentation strategy for the game project: in-game help, community resources, developer documentation. Establishes writing guidelines and tone of voice for player communication. Coordinates documentation with community management and marketing.