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.

Designs complex economic systems: multi-currency economy, dynamic pricing, auction house, player-to-player trading. Builds economic models with Monte Carlo simulation. Prevents exploitation and inflation. Balances F2P economy for LTV optimization without harming player experience.

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.

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).

Designs systemic mechanics: emergent gameplay, dynamic difficulty, procedural content generation. Creates mechanics that teach — intuitive systems that educate through gameplay. Designs cross-system interactions for deep gaming experience. Evaluates novel mechanics through rapid prototyping.

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.

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.

Designs complex narrative systems: emergent storytelling, procedural narrative, systemic storytelling through gameplay. Creates narrative direction for the entire project. Manages narrative scope and pacing for 20+ hour experience. Ensures coherent world-building.

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.

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.

Designs game UX strategy: UI framework, accessibility standards (WCAG for games), platform-specific UX. Creates design system for UI components. Implements data-driven UX optimization through analytics and A/B tests. Ensures seamless experience from first launch to endgame.

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.

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.

Designs level design methodology for the project: level art pipeline, world-building approach, metrics-driven layout. Creates open world structure: POI distribution, exploration rewards, seamless transitions. Applies psychological principles: flow state, curiosity loops, surprise/delight.

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.

Game Infrastructure 1

▼

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.

Designs data-driven game design process: predictive models for retention, churn prediction, LTV segmentation. Builds custom dashboards for game health monitoring. Uses ML models for optimizing matchmaking, difficulty, personalized offers.

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.

Game Programming 2

▼

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.

Designs complex AI systems: utility-based AI for strategic decisions, GOAP for autonomous NPCs, director AI for dynamic difficulty. Creates AI characters with convincing behavior and emotional responses. Optimizes AI performance for hundreds of simultaneous agents.

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.

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.

Designs complex physics systems: soft body physics, fluid simulation, custom physics for unique mechanics. Optimizes physics for production: deterministic physics for multiplayer, physics LOD, async physics. Creates physics design guidelines for the team.

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.

Game QA 1

▼

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.

Designs comprehensive QA strategy for the game project: automated testing framework, performance testing, compatibility testing. Creates playtesting methodology: participant recruitment, session design, data analysis. Implements continuous testing in the development pipeline.

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.

Additional skills (optional) 36

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.

Designs AI-powered tools for game design automation: procedural generation, balance testing. Creates prompt systems for large-scale game content generation with quality control. Evaluates LLM applicability for NPC dialogues and adaptive storytelling in games.

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).

Integrates AI-assisted development into game design workflow: Copilot for mechanic prototyping, ChatGPT for brainstorming game ideas, AI for test data generation. Defines AI tool usage guidelines for the game design team. Evaluates AI-generated game content quality.

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.

Designs algorithms for complex game systems: procedural content generation, adaptive difficulty, dynamic balancer. Analyzes computational complexity of game loop and optimizes tick rate. Creates efficient algorithms for spatial partitioning in large open worlds.

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.

Designs complex data structures for large-scale game systems: spatial hash for collision detection, quad-trees for open world, ECS-compatible data layouts. Optimizes memory layout for cache-friendly access in game systems. Creates data-driven architecture for balancing.

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.

Designs game system security architecture considering specifics: anti-cheat, economy protection, DRM. Implements security testing in CI/CD pipeline and conducts threat modeling for game subsystems. Develops protection against game-specific threats: speed hacking, item duplication, memory tampering.

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.

Designs complex CI/CD pipelines for game projects with artifact caching and parallel builds. Optimizes build time through incremental builds and distributed asset caching. Implements automated deployment to test servers and staging environments.

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.

Designs game system architecture with maintainability in mind: modular mechanics, data-driven design, separation of concerns. Creates reusable components for prototyping new mechanics. Implements automated game data and balance config validation.

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.

Designs cloud architecture for large-scale multiplayer games on AWS with multi-region deployment. Optimizes infrastructure for minimal latency: edge locations, game server placement, matchmaking. Implements serverless components for event-driven game subsystems.

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.

Reviews game system architecture: modularity, extensibility, data-driven approach. Evaluates change impact on balance and player experience. Conducts design reviews for new features with technical risk assessment and impact on existing systems.

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.

Designs asynchronous architectures for game systems: world streaming, dynamic level loading, network code. Implements complex concurrency patterns for multiplayer game server-side. Optimizes async pipeline to prevent rendering delays.

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.

Designs container architecture for game infrastructure: servers, analytics, build systems. Optimizes Docker images for fast game server scaling during peak loads. Implements Docker-based CI/CD pipelines for game build automation.

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.

Designs comprehensive game system visualizations: full-game system diagrams, mechanic dependency graphs, data flow for live-ops pipeline. Creates interactive diagrams for presenting game design decisions to stakeholders. Documents architecture systematically.

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.

Game Engines

▼

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.

Designs game systems in Unity at production level: custom editors, tool development for designers, addressable assets. Creates design tools: level editor, balance tuning UI, debug visualization. Optimizes Unity workflow for game design team productivity.

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.

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.

Designs game systems in Unreal at production level: Gameplay Ability System, Enhanced Input, Gameplay Tags. Creates design tools through Editor Utility Widgets. Optimizes Unreal workflow for designers: custom asset types, property editors, debug tools.

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.

Game Infrastructure

▼

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.

Designs comprehensive monetization strategy: pricing optimization, offer personalization, whale management. Builds LTV models and CAC forecasts. Creates ethical monetization framework — profitability without pay-to-win. Optimizes ad monetization: waterfall, mediation, placement.

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.

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.

Designs scalable live-ops system: event framework, content pipeline, A/B testing infrastructure. Creates personalized events based on player segmentation. Optimizes live-ops for KPIs: ARPDAU, session frequency, retention. Prevents content drought through strategic planning.

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.

Game Platforms

▼

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.

Designs mobile game strategy: market positioning, target audience, UA considerations in design. Creates mobile-specific meta-game: clans, leaderboards, live events optimized for mobile engagement. Optimizes game design for UA efficiency: viral mechanics, ASO-friendly features.

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.

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.

Designs premium gaming experience: cinematic presentation, deep systems, high production value. Creates cross-platform game design considering platform-specific strengths. Defines feature parity and platform-exclusive content. Optimizes for certification requirements (Sony TRC, Microsoft XR, Nintendo Lotcheck).

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.

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.

Designs web game strategy: technology choices, distribution platforms, web monetization. Creates multiplayer web games with WebSocket/WebRTC. Optimizes for web-specific challenges: memory limits, tab switching, network latency. Defines hybrid approach: web + native.

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 Programming

▼

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.

Designs animation systems for production: procedural animation, IK systems, motion matching. Defines animation pipeline from concept to integration. Optimizes animation systems for performance. Creates animation style guide for consistent game feel.

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.

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.

Designs comprehensive audio system for the game project: sound design pipeline, adaptive soundtrack, procedural audio generation. Defines audio budget and optimizes performance. Creates audio direction document describing the sound palette for all game systems.

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.

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.

Designs scalable localization system: automated pipelines, TMS integration, continuous localization. Manages localization for 10+ languages within budget and timeline. Ensures quality through the LQA process. Optimizes cost through translation memory and MT post-editing.

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.

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.

Designs levels and systems considering performance constraints: streaming architecture, scalable quality settings, platform-specific optimizations. Creates performance guidelines for designers. Defines technical constraints for game design decisions.

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.

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.

Designs Git workflow for the game design team: branching strategy, merge policies, CI/CD for game builds. Uses git hooks for automated config file validation. Manages submodules for shared game libraries. Optimizes repository structure for game projects.

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.

Designs integration testing framework for game projects with scenario automation. Develops end-to-end testing strategy for multiplayer games simulating real-world conditions. Implements performance benchmarks and load testing for game servers.

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.

Designs logging system for the entire game infrastructure with centralized collection and analysis. Defines logging standards for client and server sides considering performance. Integrates logs with analytics systems for real-time game metric monitoring.

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.

Designs monitoring system for the entire game infrastructure with custom metrics and SLOs. Integrates business metrics into monitoring: retention, engagement, in-game economy health. Optimizes metric collection and storage for high-throughput game servers.

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.

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.

Designs game system architecture with deep understanding of pattern trade-offs. Adapts classic patterns for game development constraints: performance, memory layout, GC pressure. Creates custom architectural solutions combining patterns for unique game mechanics.

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.

Designs complex object models for game frameworks and engines. Combines OOP with ECS approach for optimal balance between performance and architectural purity. Refactors legacy game systems applying GRASP patterns and clean architecture.

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.

Designs high-performance PostgreSQL architectures for game platforms with partitioning and replication. Optimizes storage and queries for massive game data volumes: event logs, analytics, replay. Implements PostgreSQL extensions for specific tasks: PostGIS for geolocation, pg_cron for maintenance.

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.

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.

Develops API architecture for complex game ecosystems with microservices. Designs client-server contracts considering latency, request batching, and caching. Optimizes API design to minimize traffic in real-time games.

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.

Designs architecture for large game platforms: MMO backend, live-service infrastructure, cross-platform systems. Solves complex distributed system challenges: eventual consistency, conflict resolution for game data. Creates system design documentation and conducts architectural reviews.

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.

Technical Documentation

▼

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.

Designs technical documentation structure for the entire game project. Creates living documents that auto-update when configs change. Documents complex systems: economy, progression, meta-game. Writes technical specifications for cross-team interaction.

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.

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.

Designs test architecture for game projects considering game loop and real-time system specifics. Implements property-based testing for generating and verifying balance parameters. Automates regression testing for game mechanics and content.

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.

Designs knowledge management system for game design: taxonomy, tagging, cross-referencing. Creates living documents that update alongside the project. Implements lessons learned and postmortem processes for accumulating knowledge between iterations.

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.

Designs comprehensive in-game knowledge system: dynamic tutorials, progressive disclosure, mastery guides. Creates community documentation strategy: wiki, guides, API docs for modders. Implements metrics-driven approach: tracks which help resources players use.

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.