Backend Engineering & Performance Topics
Backend system optimization, performance tuning, memory management, and engineering proficiency. Covers system-level performance, remote support tools, and infrastructure optimization.
Platform Specific Optimization and Constraints
Understand how target-platform constraints change optimization and design decisions across a product's deployment surfaces. Mobile (iOS/Android): battery and thermal limits, constrained memory, background execution limits, and app-store binary size caps. Web: variable bandwidth, cold-start/first-load budgets, browser and device fragmentation, and no control over the client's hardware. Desktop/server: wide hardware variance (CPU/GPU/RAM tiers) with no fixed baseline to target. Real-time/console-class systems (PS5, Xbox Series X, high-refresh PC): fixed frame-time budgets (commonly 30-60 FPS on mobile, 60+ FPS on console/PC), where quality knobs like resolution, LOD, particle count, draw distance, and physics precision are scaled per platform to hit the budget. Covers how to profile per platform (Xcode Instruments, Android Profiler, browser devtools, console vendor profilers, general CPU/GPU profilers) and how to reason about which constraint (memory, power, bandwidth, latency) dominates the optimization strategy for a given target.
Performance Fundamentals and Troubleshooting
Core skills for identifying, diagnosing, and resolving general performance problems across applications and systems. Topics include establishing baselines and metrics, using monitoring and profiling tools to determine whether issues are CPU bound, memory bound, input output bound, or network bound, and applying systematic troubleshooting workflows. Candidates should be able to prioritize fixes, recommend temporary mitigations and long term solutions, and explain when to escalate to specialists. This canonical topic covers general performance awareness, common diagnostic tools, and basic remediation approaches for slow systems and resource exhaustion.
Game Engine Architecture
Comprehensive knowledge of game engine structure and runtime behavior, covering the game loop and frame execution model, scene and asset management, entity component system design and object composition patterns, lifecycle and update semantics including fixed update versus variable update timing, prefab and instancing systems, scripting system integration and interop, memory management and object pooling strategies, resource loading and streaming, plugin and extension mechanisms, engine source code exploration and customization, profiling and performance optimization across CPU, GPU, and physics, determinism and networking considerations, and best practices for structuring projects for scalability and maintainability. Includes both engine specific details such as Unity lifecycle methods and prefab workflows and general engine architecture concepts applicable to other engines.
Performance Architecture for Cross Platform Games
Design systems that perform well on diverse hardware: mobile (iOS, Android), console (PS5, Xbox Series X), PC, and web. Discuss how you'd architect for different performance budgets: 60 FPS on console, 30 FPS on mobile, 144 FPS on PC. Consider memory constraints on mobile and web. Discuss level of detail systems, draw call optimization, memory management. Design for profiling and optimization from the ground up.
Garbage Collected Memory Management
Covers memory management in managed runtimes that use garbage collection. Topics include the memory model distinguishing value types and reference types, stack and heap allocation patterns, how common garbage collection algorithms work and their runtime impacts such as pause times and allocation throughput, causes of allocation pressure, and strategies to reduce garbage collection overhead. Practical techniques include avoiding boxing, reusing and preallocating collections, using value types or structs for small frequently instantiated data, object pooling, and data oriented design trade offs versus object oriented design for performance. Candidates should also know profiling tools, memory budgeting for constrained platforms such as mobile or game consoles, and platform specific considerations for engines like Unity.
Game Debugging and Profiling
Covers debugging techniques and performance analysis specific to game development. Candidates should demonstrate familiarity with debuggers available in game engines including breakpoints, stepping, watches, and call stack inspection. Understand common game development defects such as timing and synchronization issues, null references, physics glitches, animation and state desynchronization, and platform specific runtime failures. Explain profiling workflows and tools to identify performance bottlenecks in rendering, simulation, and resource loading, including sampling and instrumentation profilers, frame time analysis, and memory and resource usage tracking. Discuss core performance concepts such as frame rate, delta time, frame budget, central processing unit and graphics processing unit hotspots, cache friendliness, and data locality. Show judgment about when to optimize and when optimization is premature, methods to build reproducible repro cases, how to measure before and after changes, and common optimization strategies for CPU, GPU, and memory.
Advanced Linux Performance and Services
Advanced administration focused on service lifecycle, process management, and system performance. Topics include deep systemd service management and unit file authoring, dependency ordering and service recovery, process lifecycle and signal handling, cgroups and resource controls, tuning kernel parameters, diagnosing CPU and memory pressure, understanding page cache and swap behavior, out of memory scenarios, I O performance analysis, interpreting load average, and using performance and sampling tools such as top, htop, pidstat, iostat, vmstat, sar, and perf for identifying bottlenecks and implementing mitigations.
Performance Strategy and Resource Efficiency
High level strategy for balancing performance, resource constraints, and cost. Topics include trade off analysis, when to optimize versus accept costs, algorithm and data structure selection under resource constraints, power and energy trade offs, memory and storage budgets, and cost aware performance design. Candidates should discuss prioritization, measurement driven decision making, and resource efficient system design.
Scaling and Performance Optimization
Centers on diagnosing performance issues and planning for growth, including capacity planning, profiling and bottleneck analysis, caching strategies, load testing, latency and throughput trade offs, and cost versus performance considerations. Interviewers will look for pragmatic approaches to scale systems incrementally while maintaining reliability and user experience.