These skills do not affect the main grade but show the breadth of your profile.
3D Graphics & Computing
▼
Configures Animation Blueprints in Unreal Engine: State Machines, Blend Spaces, Animation Montages. Understands Skeleton and AnimInstance. Works with Sequencer for cutscenes.
Develops complex animation systems in Unreal: Animation Layers, IK via Control Rig, Linked Anim Graphs. Uses Anim Notifies for gameplay events. Optimizes LOD for animations via Skeletal Mesh LOD.
Designs AAA-level animation system architecture in Unreal: Motion Matching, procedural animation via AnimGraph nodes, MetaHuman facial animation. Optimizes animation budget for 100+ animated characters.
Defines animation pipeline standards for the Unreal studio. Coordinates animators, riggers, and programmers. Establishes animation performance budgets and quality bar.
Understands GPU programming in Unreal: Nanite, Lumen, Virtual Shadow Maps. Uses GPU Visualizer for rendering performance analysis. Understands draw call optimization through instancing.
Develops GPU-optimized solutions in Unreal: custom compute shaders via HLSL, Niagara GPU particles, custom render passes via RDG (Render Dependency Graph).
Designs GPU architecture for AAA Unreal projects: custom rendering features, GPU-driven pipeline, async compute. Optimizes for specific GPU architectures (AMD RDNA, NVIDIA Ada).
Defines GPU programming strategy for the Unreal studio. Establishes rendering performance budgets. Coordinates graphics programmers and tech artists.
Understands shader development in Unreal: Material Editor for PBR materials, Material Instances, basic HLSL custom expressions. Creates basic materials and material functions.
Develops materials in Unreal: Material Functions for reuse, World Position Offset for vertex animation, custom HLSL nodes. Optimizes shader complexity and instruction count.
Designs shader pipeline for AAA Unreal projects: custom shading models, post-process materials, Niagara material integration. Modifies engine shaders for project-specific rendering.
Defines shader strategy for the Unreal studio. Establishes material standards, instruction budgets. Coordinates tech artists and graphics programmers.
AI Coding Assistants
▼
Uses ChatGPT and Claude for Unreal development: generating C++ and Blueprint logic, explaining UE API, finding solutions to Unreal-specific problems and crash debugging.
Effectively applies AI assistants for complex Unreal tasks: GAS (Gameplay Ability System) architecture, shader debugging, plugin development. Crafts prompts with Unreal-specific context.
Integrates AI assistants into the Unreal team's workflow. Creates templates for engine-level debugging, Slate/UMG code generation, networking troubleshooting. Evaluates AI-generated Unreal C++ quality.
Defines AI usage policy for the Unreal team. Establishes guidelines for AI-assisted Unreal C++ code review. Evaluates ROI and risk from AI-generated code in AAA context.
Uses Cursor for Unreal: AI-assisted C++ coding, Blueprint generation suggestions.
Configures Cursor for UE: C++ UE macros, Blueprint scripting helpers, Unreal conventions.
Optimizes Cursor: Unreal-specific prompts, performance optimization suggestions.
Defines AI IDE standards: approved configs, C++ safety review for AI suggestions.
Uses GitHub Copilot for Unreal C++ development: UCLASS/UFUNCTION autocompletion, boilerplate code generation, writing comments. Understands Copilot limitations for UE-specific code.
Effectively applies Copilot for Unreal: GAS code, Slate/UMG widgets, replication logic. Uses Copilot Chat for debugging crash reports and understanding engine internals.
Optimizes Copilot for the Unreal team: context configuration, exclusion rules for engine source. Evaluates quality for UE-specific code patterns. Establishes best practices.
Defines Copilot policy for the Unreal team. Evaluates productivity impact for AAA C++ development. Establishes guidelines for IP-safe usage.
Algorithms & Data Structures
▼
Understands basic algorithms and their complexity in the context of Unreal Engine C++ development. Applies standard STL algorithms and Unreal containers (TArray, TMap) for game data processing.
Applies medium-complexity algorithms in Unreal projects: navigation algorithms via NavMesh, spatial queries via Octree, EQS for AI decision making. Evaluates complexity when working with large Actor volumes.
Designs optimal algorithmic solutions for AAA-class Unreal projects. Uses Unreal-specific optimizations: parallel for, task graph. Optimizes algorithms for cache coherency and SIMD.
Defines algorithmic standards for the Unreal team. Conducts code reviews focused on complexity and Unreal-specific optimizations. Builds a library of algorithmic solutions for AAA projects.
Uses Unreal-specific containers: TArray, TMap, TSet, TQueue. Understands the difference between Unreal containers and STL. Selects proper containers for storing Actor references and game data.
Applies specialized Unreal containers: TSparseArray, TBitArray, TResourceArray. Uses custom allocators for optimized memory usage. Creates Unreal-compatible custom structures.
Designs cache-friendly data layouts for Unreal: Mass Entity Framework, custom data storage for large-scale simulations. Optimizes memory layout for Unreal threading model.
Defines container usage standards for Unreal projects. Establishes guidelines for Unreal vs STL containers. Trains the team on data-oriented design in the Unreal Engine context.
API Management
▼
Documents Unreal API: code comments, README, Blueprint documentation.
Creates documentation including API reference for Unreal Engine game services and Blueprints interfaces, integration guides for online subsystems and platform SDKs, and technical design documents for gameplay framework architectures.
Designs documentation strategy: automated docs, developer guides, onboarding.
Defines documentation standards for Unreal Engine game service APIs including mandatory gameplay API references, online subsystem integration guides, and platform SDK documentation requirements. Establishes review processes ensuring game API documentation meets quality standards across development teams.
Application Security
▼
Understands security for Unreal: client-side security, anti-cheat basics. Validates user input.
Implements game security: encrypted communication, server authority, anti-tampering measures.
Designs security architecture: comprehensive anti-cheat, server-authoritative design.
Defines security standards: game security guidelines, anti-cheat requirements.
Applies secure coding in Unreal: buffer overflow prevention, input validation, memory safety.
Implements security in C++: safe memory patterns, encrypted networking, secure asset delivery.
Designs secure games: memory safety architecture, anti-cheat integration, vulnerability prevention.
Defines security standards: C++ safety guidelines, memory safety requirements.
Benchmarking
▼
Understands basic performance budgets in Unreal Engine: target FPS, GPU/CPU frame time splits, draw call and poly count limits. Follows team-defined budgets for levels and actors. Uses Unreal Insights and stat commands to check frame time and reports regressions.
Independently defines performance budgets for Unreal features: per-thread CPU time allocations, GPU render pass budgets, Nanite/Lumen overhead limits and streaming pool sizes. Understands trade-offs between scalability settings and visual quality across PC and console targets. Sets up automated budget validation using Unreal Automation Framework and CSV profiling.
Designs comprehensive performance budget architectures for Unreal titles: per-thread CPU time budgets (game thread, render thread, RHI thread), GPU pass budgets with Nanite/Lumen/VSM overhead tracking, memory pool hierarchies and streaming bandwidth limits. Optimizes engine subsystems to meet budgets on min-spec hardware. Mentors the team on engine-level profiling, scalability configuration and budget-aware content creation.
Defines performance budget strategy at the team and product level for Unreal projects. Establishes per-platform frame time budgets, VRAM/RAM envelopes and streaming bandwidth allocations across all game subsystems. Creates budget ownership model with per-department allocations, automated Unreal Insights dashboards and CI-integrated budget gates. Drives cross-discipline alignment between art, level design and engineering on scalability and quality trade-offs.
Uses Unreal Insights for profiling: CPU, GPU, Memory, Network traces. Applies stat commands (stat fps, stat unit, stat scenerendering). Identifies main bottlenecks in Unreal projects.
Conducts deep profiling of Unreal projects: Unreal Insights Timing/Memory, RenderDoc, platform tools (PIX, Razor). Creates automated performance benchmarks in CI.
Designs profiling infrastructure for AAA Unreal: custom trace channels, automated regression detection, platform-specific profiling workflow. Establishes per-frame performance budgets.
Defines performance engineering culture for the Unreal team. Establishes profiling standards, regular performance reviews. Trains the team on profiling tools and methodologies.
Caching
▼
Understands Redis for Unreal backend: session caching, matchmaking data. Integrates via backend API.
Designs Redis usage: real-time leaderboards, game session state, pub/sub for events.
Designs Redis architecture: cross-server communication, real-time data distribution.
Defines caching standards: Redis patterns for games, monitoring, performance.
CI/CD
▼
Understands basic GitHub Actions for Unreal Engine: running UE build pipelines for target platforms, reading CI logs for compilation and packaging failures, understanding workflow triggers for automated builds. Follows team conventions for Unreal CI pipeline configuration.
Independently creates GitHub Actions workflows for Unreal Engine: configures automated UE build pipelines for target platforms, implements packaging and cook content automation, automates build distribution and version management. Manages Unreal CI/CD configurations.
Designs CI/CD architecture for Unreal Engine: optimizes UE build pipelines for large project compilation times, implements progressive delivery for game content updates, architects automated packaging and distribution workflows. Mentors team on Unreal CI/CD best practices.
Defines DevOps strategy for Unreal teams: establishes CI/CD standards for UE build infrastructure, implements platform engineering approaches for large-scale game project delivery, drives adoption of automated packaging and content deployment.
Cloud Providers
▼
Works with AWS for Unreal: S3 for content delivery, GameLift basics. Understands cloud game hosting.
Integrates Unreal with AWS: GameLift dedicated servers, CloudFront CDN, DynamoDB for player data.
Designs cloud architecture: GameLift scaling, global infrastructure, serverless backend.
Defines cloud standards: service selection, cost optimization, infrastructure review.
Code Review
▼
Participates in code review of Unreal C++ code: checks coding standards, UPROPERTY correctness, memory management. Learns to give feedback on Blueprint-heavy and C++ code.
Conducts deep review of Unreal C++ code: memory management (GC, shared pointers), thread safety, replication correctness. Verifies Blueprint integration and performance implications.
Shapes review culture in the Unreal team. Defines review guidelines for C++, Blueprints, Materials, Niagara. Automates checks via CI: compile, static analysis, automated tests.
Defines the code review process for AAA Unreal projects. Establishes review metrics and trains the team. Conducts architectural reviews for critical engine-level changes.
Concurrency & Parallelism
▼
Understands async in Unreal: async loading, delegates, latent actions. Handles async asset loading.
Implements async patterns: async tasks, FRunnable for background processing, streaming level loading.
Designs async architecture: multi-threaded asset pipeline, async content streaming, parallel processing.
Defines async standards: threading policies, async patterns, performance guidelines.
Understands the fundamentals of Multithreading at a basic level. Applies simple concepts in work tasks using C++/Blueprints. Follows recommendations from senior developers when solving problems.
Independently applies multithreading for Unreal Engine: FRunnable and task graph system, async loading with streaming, game thread vs render thread separation, parallel gameplay system updates. Explains concurrency trade-offs for Unreal Engine threading model.
Has deep expertise in Unreal Engine multithreading: designs custom task graph systems for parallel gameplay processing, implements thread-safe subsystems for concurrent game logic, optimizes Unreal's threading model for target platform requirements. Mentors team on UE-specific concurrent programming for AAA game development.
Defines multithreading standards for Unreal teams: establishes guidelines for task graph and threading model usage, conducts reviews of concurrent gameplay system designs, creates training materials on UE-specific concurrent programming patterns.
Containerization
▼
Understands basic Docker concepts for Unreal development: containerized build agents for UE projects, Docker images for CI dependencies, basic docker-compose for dedicated server testing. Uses existing configurations for Unreal build environment containers.
Independently configures Docker for Unreal projects: containerized build agents for UE, docker-compose for dedicated server testing, Dockerfile for UE build environment images. Understands container resource management for large UE builds and network configuration for game server containers.
Designs Docker infrastructure for Unreal Engine projects: containerized build farm architecture, optimized images for large UE builds, dedicated server container orchestration. Implements best practices for UE build caching in containers and artifact distribution across build agents.
Defines Docker infrastructure strategy for Unreal projects: build farm container standards, dedicated server container governance, build caching and artifact distribution policies. Conducts architecture reviews for containerized UE build infrastructure and optimizes FinOps for build resources.
Game Design
▼
Understands basic game mechanics in Unreal: Actor lifecycle, collision channels, Blueprint visual scripting. Implements simple mechanics using Blueprints following team conventions. Uses Unreal property system to expose gameplay parameters.
Independently implements Game Mechanics Design in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs production-grade game mechanics systems in Unreal: GAS (Gameplay Ability System), custom movement components, and networked gameplay prediction. Optimizes mechanics with C++ for performance-critical paths. Mentors team on GAS architecture patterns.
Defines technical strategy for Unreal game mechanics systems. Establishes GAS architecture standards, Blueprint/C++ boundary guidelines, and replication strategies. Coordinates technical direction for gameplay, animation, and networked mechanics systems.
Understands Unreal UI basics: UMG widget system, Blueprint-driven UI logic, and input mapping for game interfaces. Builds simple HUD widgets, menus, and notification systems following UX specifications. Follows team standards for widget hierarchy, screen adaptation, and Enhanced Input integration.
Independently implements Game UX and UI Design in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs comprehensive UMG UI systems in Unreal with C++ backend logic, Common UI plugin, and data-driven widget architecture. Implements polished UX with animations, gamepad/keyboard navigation, and platform-adaptive layouts. Mentors team on UI performance optimization and user experience validation.
Defines game UX technical strategy for Unreal projects: establishes UMG architecture standards, Common UI adoption policies, and input handling conventions. Coordinates UX efforts between design, art, and engineering teams ensuring consistent player experience across platforms and input devices.
Game Engines
▼
Understands Unreal Asset Pipeline: Content Browser, Data Assets, Primary/Secondary Assets. Imports models (FBX), textures, audio. Uses Blueprints for asset references. Understands asset cooking.
Manages Asset Pipeline in Unreal: Asset Manager for async loading, Streaming Levels, Data Layers. Configures asset cooking for different platforms. Optimizes pak files and DLC content.
Designs scalable asset pipeline for AAA Unreal projects: Virtual Assets, Derived Data Cache, custom asset types. Optimizes iteration time and build pipeline for large teams.
Defines asset pipeline standards for the Unreal studio. Establishes naming conventions, validation rules, automated QA. Coordinates workflow between art, level design, and engineering.
Creates game logic in Unreal Blueprints: Event Graph, macros, functions. Works with Blueprint Communication: casting, interfaces, event dispatchers. Understands when to use Blueprint vs C++.
Develops complex Blueprint systems: Animation Blueprints, Material Blueprints, Widget Blueprints. Optimizes Blueprint nativization and performance. Uses Blueprint Function Libraries.
Designs Blueprint architecture for Unreal projects: C++/Blueprint boundary, data-driven Blueprints, Blueprint nativization strategy. Creates designer-friendly Blueprint frameworks.
Defines Blueprint standards for the Unreal team. Establishes C++ vs Blueprint guidelines. Trains designers and technical artists in effective Blueprint usage.
Game Infrastructure
▼
Integrates analytics into Unreal projects: custom events via analytics providers (GameAnalytics, Amplitude). Sends telemetry for tracking player progression and key metrics.
Designs analytics system for Unreal games: event taxonomy, funnel analysis, A/B testing via remote config. Creates dashboards for game designers and producers.
Designs data pipeline for AAA Unreal projects: real-time telemetry, data warehouse, predictive analytics. Uses Unreal Insights integration for performance analytics.
Defines analytics strategy for the Unreal studio. Establishes data governance and privacy compliance. Coordinates analytics between game design, production, and engineering.
Understands game backend integration from Unreal: connects to PlayFab/Nakama services for player profiles, authentication, and inventory management. Implements basic backend SDK integration using Unreal's HTTP and WebSocket subsystems. Follows team patterns for async backend communication.
Independently implements Game Backend in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs production game backend systems integrated with Unreal: custom server authoritative logic, PlayFab economy systems, and Nakama real-time multiplayer modules. Optimizes network replication, implements server-side validation, and handles cross-platform backend compatibility.
Defines game backend strategy for Unreal projects: selects backend platforms, establishes networking architecture standards, and sets performance/cost targets for online services. Reviews server architecture decisions ensuring scalability for concurrent players and cross-platform play.
Understands multiplayer architecture in Unreal: GameMode/GameState/PlayerState framework, server types (dedicated/listen). Implements basic multiplayer with session management.
Designs multiplayer systems in Unreal: matchmaking, lobby management, team assignment. Implements authoritative game logic. Integrates Epic Online Services (EOS) for cross-platform play.
Designs scalable multiplayer architecture for AAA: microservices backend, horizontal scaling, seamless travel. Uses Multiplay/GameLift for dedicated server orchestration.
Defines multiplayer strategy for the Unreal studio. Establishes networking architecture standards, backend infrastructure decisions. Coordinates client and server development.
Game Platforms
▼
Builds Unreal projects for different platforms: Windows, PlayStation, Xbox, Switch. Understands Platform Abstractions in Unreal. Configures project settings for each target platform.
Automates cross-platform Unreal builds: BuildGraph, Horde build system, cooking pipeline. Manages platform SDKs and devkits. Optimizes package size through chunk management.
Designs cross-platform architecture for Unreal projects: platform HAL, quality scalability, conditional content. Ensures feature parity and platform-specific optimizations.
Defines cross-platform strategy for the Unreal studio. Establishes build infrastructure, platform matrix. Coordinates certification (TRC/TCR/Lotcheck) across all platforms.
Understands the fundamentals of Mobile Game Development. Applies basic practices in daily work. Follows recommendations from the team and documentation.
Independently implements Mobile Game Development in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs Mobile Game Development solutions for production games. Optimizes for target platforms. Mentors the team.
Defines technical strategy for Mobile Game Development. Establishes development standards. Coordinates technical direction.
Develops Unreal games for PC and consoles: gamepad input via Enhanced Input System, resolution settings, HDR output. Understands certification requirements (TRC/TCR/Lotcheck).
Optimizes Unreal games for PC/Console: Scalability settings, platform-specific rendering (Nanite/Lumen tuning), memory budgets. Implements platform features: achievements, save data.
Designs AAA quality PC/Console experience in Unreal: DLSS/FSR/XeSS integration, ray tracing scalability, platform-specific optimizations. Ensures certification compliance.
Defines PC/Console strategy for the Unreal studio. Establishes platform compliance process. Coordinates platform-specific optimization and certification pipeline.
Understands Unreal for web: Pixel Streaming for browser-based gaming. Configures Pixel Streaming server for running Unreal content in the browser without downloading.
Develops Pixel Streaming solutions: multi-user sessions, input handling, adaptive quality. Optimizes encoding settings (bitrate, resolution) for various bandwidth conditions.
Designs scalable Pixel Streaming architecture: auto-scaling GPU fleet, CDN integration, client-side prediction for reduced latency. Evaluates cost optimization strategies.
Defines web distribution strategy for the Unreal studio. Establishes Pixel Streaming infrastructure standards. Coordinates web deployment and DevOps.
Game Programming
▼
Writes C++ code for Unreal Engine: Actor, Component, GameMode classes. Understands Unreal-specific C++: UPROPERTY, UFUNCTION, garbage collection. Uses TArray, TMap, TSet and Smart Pointers.
Develops complex systems in Unreal C++: Gameplay Ability System, custom AI controllers, async operations. Uses delegates, interfaces, subsystems. Profiles C++ via Unreal Insights.
Expert-level Unreal C++: engine modification, custom modules, plugin development. Uses Unreal Build Tool, customizes Slate UI framework. Optimizes C++ for consoles: SIMD, cache optimization.
Defines C++ development standards for the Unreal studio. Shapes module architecture, coding guidelines. Serves as technical authority on Unreal C++ and engine internals.
Understands basic Game AI in Unreal: Behavior Trees, Blackboard, and AI Controllers with navigation mesh. Follows team patterns for implementing NPC behavior using Blueprint visual scripting and EQS (Environment Query System).
Independently implements Game AI in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs production Game AI systems in Unreal: complex Behavior Trees, EQS-driven tactical decisions, Smart Objects, and crowd simulation. Optimizes AI perception system and pathfinding for open-world scenarios. Mentors team on AI patterns.
Defines technical strategy for Unreal Game AI systems. Establishes Behavior Tree conventions, EQS design guidelines, and AI profiling standards. Coordinates technical direction for AI, animation, and level design integration.
Understands Unreal animation fundamentals: Animation Blueprints, montages, blend spaces, and state machines. Sets up basic character animation pipelines using Unreal's Animation System. Follows team conventions for animation asset import, retargeting, and skeleton management.
Independently implements Game Animation Systems in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs production animation systems in Unreal: advanced Animation Blueprints, Control Rig, procedural animation, and motion warping. Optimizes animation memory and CPU usage for target platforms through pose caching and LOD strategies. Mentors team on complex blend graphs and linked anim layers.
Defines animation technology strategy for Unreal projects: evaluates animation tools and plugins, establishes pipeline standards between animators and engineers, and sets memory/CPU budgets. Reviews animation architectures for scalability across game modes and platforms.
Integrates audio in Unreal: Sound Cues, Sound Classes, Attenuation Settings. Configures 3D sound with distance attenuation and spatialization. Understands Audio Volumes and Reverb Effects.
Develops audio systems in Unreal: Wwise/FMOD integration, MetaSounds for procedural audio, Sound Concurrency for voice management. Optimizes audio streaming and memory.
Designs audio architecture for AAA Unreal projects: middleware selection, audio occlusion system, spatial audio for 3D environments. Develops custom audio solutions.
Defines audio pipeline strategy for the Unreal studio. Establishes audio middleware standards, voice budget. Coordinates sound designers and audio programmers.
Understands Unreal rendering basics: material editor, shader model concepts, and deferred vs forward rendering. Applies basic material setups using Blueprint material functions. Follows team guidelines for texture streaming, mesh LOD configuration, and lighting build settings.
Independently implements Game Rendering in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs advanced rendering solutions in Unreal: custom shading models, Nanite integration, and Lumen global illumination tuning. Optimizes rendering for target platforms using RenderDoc, GPU profilers, and scalability settings. Mentors team on HLSL optimization and rendering architecture decisions.
Defines rendering technical strategy for Unreal projects: establishes material authoring standards, scalability profiles, and visual quality targets across platforms. Coordinates rendering pipeline decisions between art, tech art, and engineering to deliver consistent visual fidelity at target performance.
Creates UI in Unreal with UMG (Unreal Motion Graphics): Widget Blueprints, HUD, menus. Understands Canvas Panel, overlays, anchoring. Binds UI to game logic via Blueprints.
Develops complex UI systems in Unreal: Common UI for cross-platform input, Rich Text, data binding via ViewModels. Optimizes Slate rendering: batching, invalidation, retainer boxes.
Designs UI architecture for AAA Unreal projects: MVVM with UMG ViewModel, Slate for custom widgets, accessibility. Implements UI streaming to minimize memory footprint.
Defines UI standards for the Unreal studio. Establishes UI component library, design system. Coordinates UX designers and UI programmers for AAA quality UI.
Understands Chaos Physics engine in Unreal: rigid body simulation, collision detection, physics materials. Configures Physical Materials (friction, restitution) for realistic gameplay.
Works with advanced Chaos features: Chaos Destruction, Cloth simulation, physics constraints (joints). Configures physics sub-stepping for simulation stability.
Designs physics systems with deep understanding of Chaos internals. Modifies Chaos solver parameters for project-specific needs. Implements custom physics via Chaos interfaces.
Defines physics engine standards for the Unreal studio. Establishes Chaos configuration guidelines and performance budgets. Coordinates physics and gameplay teams.
Creates procedural systems in Unreal: PCG (Procedural Content Generation) framework, random placement, noise-based terrain. Uses Blueprints and PCG graphs for generation rules.
Develops advanced PCG systems in Unreal: custom PCG nodes, rule-based generation, biome systems. Ensures seed-based reproducibility and artist-friendly controls for fine-tuning.
Designs scalable PCG systems for AAA Unreal: infinite world streaming, GPU-accelerated generation, deterministic generation for multiplayer. Integrates with World Partition.
Defines procgen strategy for Unreal projects. Establishes PCG pipeline with art direction controls. Coordinates level designers, artists, and programmers.
Game QA
▼
Understands Unreal localization fundamentals: FText, string tables, localization dashboard, and culture-aware formatting. Implements basic text localization for UMG widgets and game dialogs. Follows team standards for using FText consistently, text gathering, and translation workflows.
Independently implements Game Localization in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs production localization pipelines in Unreal: automated text gathering, translation memory integration, CJK text rendering optimization, and voice-over localization workflows. Implements efficient asset streaming for localized content and handles platform certification requirements for supported languages.
Defines localization strategy for Unreal projects: evaluates translation management systems, establishes workflows between engineering and localization teams, and sets quality benchmarks. Reviews localization pipelines ensuring efficient turnaround, minimal string freeze impact, and consistent terminology.
Understands Unreal Engine performance basics: tick groups, actor lifecycle, and rendering budgets. Uses Unreal Insights and stat commands to identify frame time spikes. Follows team standards for Blueprint nativization, asset streaming, and level-of-detail configuration.
Independently implements Game Performance Optimization in Unreal Engine 5. Optimizes performance. Works with profiler.
Designs high-performance Unreal systems using Nanite, Lumen, and World Partition for large-scale games. Optimizes C++ gameplay code, thread scheduling, and async loading. Mentors the team on platform-specific profiling with Unreal Insights, RenderDoc, and console dev kits.
Defines Unreal performance strategy for studio projects: establishes scalability settings standards, automated benchmark suites, and performance gates in CI/CD. Coordinates optimization efforts across gameplay, rendering, and content teams for multi-platform releases.
Understands Unreal project testing: Automation Framework, Functional Tests, Gauntlet for automated testing. Writes simple tests for game logic. Uses Session Frontend for test execution.
Develops testing infrastructure for Unreal: automated gameplay tests, performance regression testing, screenshot comparison tests. Integrates testing into Horde CI pipeline.
Designs testing strategy for AAA Unreal projects: automated playthrough testing, network testing, platform compliance testing. Implements chaos testing for multiplayer stability.
Defines testing culture for the Unreal team. Establishes test coverage requirements, QA integration. Coordinates automated and manual testing teams for AAA quality bar.
Git & Workflows
▼
Works with version control for Unreal: Perforce or Git with LFS. Understands workspace setup, changelist management. Performs basic operations: checkout, submit, resolve conflicts.
Applies advanced VCS techniques for Unreal: stream-based branching in Perforce, shelving for code review, automated workspace setup. Configures triggers for validation.
Designs VCS workflow for large Unreal projects: multi-site Perforce, distributed builds, workspace optimization. Solves scaling challenges with 50+ developers.
Defines VCS strategy for the Unreal studio. Establishes branching policy, submit guidelines. Coordinates VCS infrastructure with IT and build engineering.
Clones Unreal Engine projects with Git LFS and handles initial asset downloads. Recognizes that .uasset, .umap, and blueprint files require LFS tracking due to their binary nature. Follows existing .gitattributes configurations for Unreal content without altering tracking rules.
Maintains .gitattributes rules for Unreal projects covering .uasset, .umap, blueprint, and derived data cache files. Uses LFS file locking to coordinate binary asset edits among team members and prevent conflicts on non-mergeable content. Configures sparse checkout patterns to reduce local storage for large Unreal repositories.
Architects Git LFS infrastructure for large Unreal projects with massive .uasset and .umap repositories spanning hundreds of gigabytes. Designs custom LFS storage backends and transfer protocols optimized for Unreal's binary asset structure. Establishes team-wide locking conventions for blueprints and level files, integrating with Unreal's own revision control features.
Establishes team-wide Git LFS standards for Unreal asset management including .uasset/.umap tracking, blueprint locking protocols, and derived data cache exclusions. Coordinates migration strategies for legacy Unreal projects transitioning to LFS-backed repositories. Mentors developers on Unreal-specific LFS workflows and resolves complex versioning issues with binary content.
GraphQL
▼
Understands GraphQL for Unreal backend: query API for game data, flexible fetching.
Integrates GraphQL: efficient data queries, subscriptions for real-time, type-safe clients.
Designs GraphQL architecture: game data API, caching, offline support.
Defines GraphQL standards: schema design, performance, security.
Integration Testing
▼
Tests Unreal integrations: Automation Framework for integration tests. Verifies gameplay flows.
Designs integration tests: multi-system testing, network integration, asset pipeline validation.
Defines integration testing: CI-based UE testing, automated build validation, platform testing.
Implements testing standards: mandatory automation tests, platform validation, quality gates.
Kubernetes & Orchestration
▼
Understands K8s for Unreal backend: containerized game servers, basic deployment.
Deploys Unreal servers in K8s: Agones for dedicated servers, auto-scaling, health checks.
Designs K8s architecture: Agones fleet management, multi-region deployment, scaling.
Defines K8s standards: game server deployment patterns, scaling policies.
Logging
▼
Uses UE logging: UE_LOG macro, log categories. Understands log verbosity levels and filtering.
Implements structured logging: custom log categories, structured output, crash reporting integration.
Designs logging architecture: centralized log collection, analytics, crash analysis pipeline.
Defines logging standards: log categories, format, collection infrastructure.
Memory Management
▼
Understands the fundamentals of Memory Management at a basic level. Applies simple concepts in work tasks using C++/Blueprints. Follows recommendations from senior developers when solving problems.
Understands Unreal Engine memory architecture: UObject lifecycle, garbage collection, and smart pointers (TSharedPtr, TWeakPtr, TUniquePtr). Uses UPROPERTY() macros correctly for GC integration. Manages asset memory through streaming and reference counting. Profiles memory with Unreal Insights and understands platform-specific memory budgets.
Designs memory architectures for Unreal Engine projects: custom memory allocators (FMallocBinned, FMallocAnsi), streaming level memory management, and texture pool optimization. Implements memory budgeting systems per platform (console certification requirements). Uses LLM (Low Level Memory) tracker for detailed allocation analysis. Creates memory regression tests for automated builds. Mentors team on UObject lifecycle patterns and smart pointer best practices.
Defines memory management standards for Unreal Engine development teams. Establishes platform-specific memory budgets aligned with certification requirements. Conducts architectural reviews of streaming, rendering, and gameplay memory systems. Creates guidelines on custom allocator selection, UObject lifecycle management, and texture streaming configuration.
Understands the fundamentals of Memory Profiling at a basic level. Applies simple concepts in work tasks using C++/Blueprints. Follows recommendations from senior developers when solving problems.
Independently uses Unreal memory profiler for UObject allocation tracking and texture streaming analysis. Understands trade-offs between level-of-detail memory budgets and rendering quality in production builds.
Has deep expertise in Unreal memory profiler, optimizes UObject allocation patterns and texture streaming for production. Tunes level-of-detail memory budgets, eliminates asset duplication, and ensures stable performance across target platforms.
Defines memory profiling standards at team level: UObject allocation budgets per module, texture streaming policies, LOD memory limits by platform, and mandatory profiler gates in CI. Establishes review workflows for memory-intensive subsystems.
Metrics & Monitoring
▼
Monitors Unreal servers via Prometheus/Grafana: server FPS, player count, network metrics.
Creates game monitoring: server performance dashboards, matchmaking metrics, player activity.
Designs monitoring: comprehensive game telemetry, automated alerts, performance tracking.
Defines monitoring standards: mandatory metrics, dashboards, alerting policies.
Networking
▼
Understands networking for Unreal: UE networking model, replication, RPCs. Configures basic multiplayer.
Implements game networking: replication graph, relevancy, client prediction, bandwidth optimization.
Designs network architecture: custom replication, dedicated server architecture, lag compensation.
Defines networking standards: network model selection, bandwidth budgets, protocol design.
OOP & Design Patterns
▼
Applies Unreal-specific patterns: GameplayAbility for ability systems, Components for composition, Subsystems for services. Uses delegates and interfaces for decoupling.
Applies advanced Unreal patterns: Gameplay Ability System (GAS), Data-Driven Design via DataTables, Async patterns with Latent Actions. Uses Gameplay Tags for flexible categorization.
Designs AAA Unreal project architecture: Modular Gameplay via Game Features, plugin-based architecture, custom framework layers. Ensures extensibility for DLC and live-service.
Defines architectural patterns for the Unreal studio. Establishes decision framework for choosing architecture by project type. Conducts architecture reviews and mentoring.
Understands the fundamentals of OOP & SOLID Principles at a basic level. Applies simple concepts in work tasks using C++/Blueprints. Follows recommendations from senior developers when solving problems.
Independently applies OOP/SOLID in Unreal Engine/C++: proper UObject/AActor inheritance hierarchies, interface-based gameplay systems (UInterface), single responsibility in components and subsystems. Understands trade-offs between Unreal's deep class hierarchy and composition with ActorComponents.
Applies OOP/SOLID in Unreal Engine architecture: proper UObject/AActor hierarchy design, interface classes (UInterface) for clean abstraction boundaries, component pattern for reusable gameplay behaviors. Designs extensible game systems using UE's module system with clean separation between gameplay, UI, and engine integration.
Defines OOP/SOLID standards for Unreal team: UObject/AActor hierarchy guidelines, UInterface usage patterns, ActorComponent composition standards. Conducts reviews of class inheritance decisions in Unreal Engine C++ and Blueprint projects.
Optimization
▼
Understands basic latency concepts for Unreal Engine: frame time budgets, rendering pipeline stages, and input-to-display delay. Uses Unreal Insights and stat commands to measure performance. Follows team guidelines on tick group configuration and actor update frequency.
Optimizes Unreal Engine latency: implements level-of-detail (LOD) systems for rendering performance, configures async loading to prevent hitches, and optimizes Blueprint tick frequency. Profiles GPU and CPU frame time using Unreal Insights. Implements occlusion culling and draw call batching for rendering pipeline optimization.
Designs latency-optimized Unreal Engine architectures: custom rendering passes for frame time consistency, streaming world partition strategies, and Nanite/Lumen performance tuning. Implements frame pacing and variable rate shading for consistent perceived performance. Designs performance budgeting systems per platform. Mentors team on engine-level latency optimization and profiling workflows.
Defines latency optimization strategy for Unreal Engine projects across platforms. Establishes frame time budgets per platform and rendering feature. Conducts architectural reviews of rendering, physics, and gameplay tick systems. Creates performance testing pipelines with automated frame time regression detection.
Profiling
▼
Understands basics of CPU profiling in Unreal Engine. Uses Unreal Insights and stat commands (stat unit, stat game) to identify frame time issues. Follows team guidelines for capturing profiling sessions and reading CPU thread timelines.
Independently profiles Unreal projects using Unreal Insights, CSV profiling, and platform-specific tools. Identifies CPU bottlenecks in game thread, render thread, and async tasks. Understands trade-offs between Blueprint Nativization and C++ for CPU-critical gameplay logic.
Designs CPU profiling strategies for AAA Unreal projects across PC and console platforms. Uses Superluminal, RAD Telemetry, and platform SDKs (PIX, Razor) for deep analysis alongside Unreal Insights. Optimizes task graph scheduling, animation budgets, and AI tick groups. Mentors team on CPU profiling methodology for shipping titles.
Defines CPU profiling strategy for Unreal development teams. Establishes per-frame CPU budgets for game, render, and RHI threads. Integrates automated profiling into build pipelines with regression alerts. Conducts cross-discipline performance reviews covering gameplay, animation, physics, and AI systems.
Understands basic asset I/O profiling in Unreal Engine — pak file reads, shader loading, and streaming latency. Uses Unreal Insights and platform profilers to identify slow asset loads. Follows team guidelines for asset packaging and reducing disk seeks during level transitions.
Independently profiles asset streaming I/O using Unreal Insights and platform disk profilers. Understands trade-offs between pak compression levels and decompression CPU cost. Optimizes async loading priorities, texture streaming pools, and level streaming to maintain gameplay without I/O stalls.
Designs I/O profiling pipelines for large Unreal Engine titles across PC, console, and mobile. Optimizes pak file layouts for sequential reads on HDD and NVMe. Implements custom asset preloading and I/O budgeting frameworks. Mentors team on diagnosing streaming hitches and disk bottlenecks.
Defines I/O profiling and asset streaming standards at the project level for Unreal Engine titles. Establishes I/O budgets per platform (HDD, SSD, optical) and enforces pak ordering. Conducts reviews of level streaming, async loading, and DLC packaging. Drives automated I/O regression testing.
Understands basic memory profiling concepts in Unreal Engine including UObject lifecycle, garbage collection, and memory pools. Uses Unreal Insights and stat memory commands to capture basic memory data under supervision. Identifies straightforward memory issues such as unreferenced assets staying in memory by following team profiling guidelines.
Independently applies Unreal memory profiling using Unreal Insights, LLM (Low-Level Memory Tracker), and MallocProfiler to diagnose memory issues. Understands trade-offs between streaming and resident memory strategies for different asset types. Optimizes texture streaming pools, reduces UObject count overhead, and resolves memory budget violations on target platforms like consoles or mobile devices.
Designs memory profiling infrastructure for Unreal projects — automated LLM budget tracking in CI, custom memory stat groups, and platform-specific memory regression testing for consoles. Optimizes memory layouts of gameplay systems using profiling data from Unreal Insights, Stomp allocator analysis, and platform SDK memory tools. Mentors the team on streaming architecture, memory pool tuning, and reducing peak memory through level-of-detail and asset dependency optimization.
Defines memory profiling strategy at the team and product level for Unreal Engine projects. Establishes per-platform memory budgets using LLM tags, enforces memory regression testing in CI with Unreal Insights automation, and standardizes memory guidelines for content creators and gameplay programmers. Conducts architecture reviews of streaming systems, world partition memory impact, and asset reference chains. Drives adoption of memory-aware development practices across all disciplines.
Prompt Engineering
▼
Crafts prompts for AI tools in the context of Unreal C++ development. Uses chain-of-thought to obtain correct UE-specific code with UPROPERTY/UFUNCTION.
Applies advanced prompt techniques for Unreal: context-aware prompts with engine architecture, role-based prompting for C++ review, structured output for data tables.
Develops prompt libraries for the Unreal team: templates for engine debugging, crash analysis, replication troubleshooting. Evaluates LLM capabilities for Unreal C++.
Defines prompt engineering practices for the Unreal team. Builds knowledge base for AI tools with Unreal-specific context. Evaluates AI effectiveness.
Relational Databases
▼
Understands PostgreSQL for Unreal backend: player data storage, game state persistence. Integrates via API.
Designs data architecture: game state persistence, player profiles, analytics data.
Designs database architecture: real-time game data, analytics, multi-region access.
Defines data standards: schema guidelines, data contracts, performance requirements.
REST API
▼
Understands REST API for Unreal: HTTP module for API calls, JSON parsing. Integrates with backend game services.
Designs API integration: REST client in C++/Blueprints, retry logic, offline handling.
Designs API architecture: backend communication, batching, CDN integration for game content.
Defines API standards: client SDK design, data contracts, error handling.
System Design
▼
Understands basic game system design principles in Unreal: Gameplay Framework hierarchy, Components vs Inheritance, DataAssets for configuration. Designs simple gameplay systems.
Designs medium-complexity game systems in Unreal: save system with versioning, economy system with server validation, progression system via GAS attributes.
Designs AAA Unreal project architecture: Game Features for modularity, plugin-based systems, mod support via pak files. Ensures long-term maintainability.
Defines architectural standards for the Unreal studio. Establishes reference architectures. Conducts architecture reviews and mentoring on system design.
Unit Testing
▼
Writes tests for Unreal with Automation Framework: simple unit tests for game logic, Functional Tests for integration. Understands test categories: SmokeTest, ProductionTest.
Develops testing strategy for Unreal: mock objects for subsystems, test world setup, Blueprint test utilities. Integrates testing into Horde CI with automated reporting.
Designs testing architecture for AAA Unreal: testable C++ patterns with DI through Subsystems, custom test framework extensions. Implements property-based testing for game systems.
Defines testing standards for the Unreal team. Establishes test requirements, review criteria. Trains the team in testing practices for AAA game development.
Understands basic unit testing in Unreal Engine: Automation Testing Framework setup, simple functional tests for gameplay systems, assertion patterns for actor behavior. Follows team practices for testing game logic in isolation from engine rendering.
Independently writes unit tests in Unreal Engine: Automation tests for gameplay systems, mock components for actor isolation, edge case coverage for networking and replication. Integrates UE tests into CI/CD with automated functional test suites and regression coverage.
Designs testing strategy for Unreal Engine projects: Automation test pyramid for gameplay/networking/rendering layers, deterministic replay testing, performance regression testing for frame budgets. Optimizes UE test execution with dedicated test servers. Mentors team on testing multiplayer and replication systems.
Defines testing strategy at product level for Unreal projects: Automation test standards, networking/replication testing governance, content validation frameworks. Establishes shift-left testing culture with automated quality gates for UE game builds.
VR Development
▼
Integrates VR in Unreal: OpenXR plugin, VR Pawn setup, Motion Controller components. Configures VR spectator view. Creates basic VR interactions: grab, teleport.
Develops VR functionality in Unreal: hand tracking via OpenXR, haptic feedback, spatial audio. Integrates platform-specific SDK (Meta XR, SteamVR). Optimizes VR comfort.
Designs VR architecture for AAA Unreal VR: multi-platform VR support, VR-specific rendering pipeline, advanced locomotion systems. Optimizes for VR performance targets.
Defines VR development strategy for the Unreal studio. Establishes VR UX guidelines and performance standards. Coordinates VR design and development.
XR Platforms
▼
Implements basic XR interactions in Unreal: VR Interaction Framework for grab, use, UI interaction. Configures XR Pawn with Motion Controllers and hand tracking input.
Develops advanced XR interactions in Unreal: two-handed physics manipulation, gesture-based controls, haptic-driven feedback. Creates custom interaction components.
Designs XR interaction framework for Unreal: modular architecture, cross-platform abstraction, accessibility. Integrates eye tracking and advanced spatial interaction.
Defines XR interaction standards for the Unreal studio. Establishes interaction design language and UX guidelines. Coordinates XR designers and developers.
Optimizes Unreal XR applications: instanced stereo rendering, Fixed Foveated Rendering, draw call reduction. Understands VR framerate requirements (72/90/120 Hz). Uses stat commands.
Applies advanced XR optimizations in Unreal: VR forward renderer, mobile multi-view, dynamic resolution, Vulkan optimizations for Quest. Profiles via OVR Metrics Tool and RenderDoc.
Designs XR performance architecture for AAA Unreal VR: adaptive quality framework, GPU/CPU budget management, platform-specific rendering paths. Develops custom profiling tools.
Defines XR performance standards for the Unreal studio. Establishes per-platform budgets. Coordinates optimization across graphics, gameplay, and platform teams.