Game Developer interview questions
100 real questions with model answers and explanations for Senior Game Developer candidates.
See a Game Developer resume example →Practice with flashcards
Spaced repetition · Hunter Pass
Questions
I would capture matched CPU and GPU frames before changing content.
- Use Unreal Insights or Tracy to separate game, render, and RHI thread time across 200 frames.
- Inspect PIX or RenderDoc for draw-call count, state changes, overdraw, and the longest GPU passes.
- Prove the fix by restoring a 16.67 ms frame at the same camera path and visual settings.
Why interviewers ask this: This tests whether the candidate diagnoses a measured frame regression instead of guessing.
I would budget both processors below 14 ms to preserve roughly 2.5 ms of spike headroom.
- Trace overlap first because 11 ms CPU and 15 ms GPU usually make the frame GPU-bound, not 26 ms serial.
- Set subsystem caps such as 4 ms gameplay, 3 ms animation and physics, and 10 ms graphics based on the capture.
- Gate representative scenes at P95 frame time, since a 16.0 ms average still produces visible misses.
Why interviewers ask this: This reveals whether the candidate understands parallel frame timing and practical headroom.
I would use archetype chunks with structure-of-arrays storage and schedule systems over disjoint chunk ranges.
- Keep hot components contiguous and move rare data such as names out of movement and combat chunks.
- Express read and write sets so the job graph can run independent systems without coarse locks.
- Validate cache misses, job overhead, and P99 update time with 10,000 active rather than sleeping entities.
Why interviewers ask this: This checks cache-aware ECS design and safe parallel execution at the stated scale.
I would keep execution code small and move tunable ability definitions into validated, versioned data assets.
- Model costs, cooldowns, tags, targeting, and effects as composable records rather than 120 subclasses.
- Compile or validate assets in CI for missing references, invalid tag combinations, and deterministic ordering.
- Record ability version and random seed in replays so a balance patch does not corrupt diagnostics.
Why interviewers ask this: This evaluates whether architecture supports rapid iteration without sacrificing runtime correctness.
I would keep only technology that creates product advantage and buy the rest through stable engine boundaries.
- Prototype the unique simulation or renderer in 6 weeks and require measured gains over Unreal on target hardware.
- Retain Unreal tooling, platform support, asset cooking, and crash reporting unless they block a written requirement.
- Define adapters around input, physics, and online services so one vendor choice cannot spread through gameplay code.
Why interviewers ask this: This tests a bounded engine decision tied to schedule and measurable differentiation.
I would bisect the first divergent tick using state hashes and compare the exact inputs and contact order.
- Hash quantized authoritative state each tick and dump only the entities that differ at the first mismatch.
- Remove unordered iteration, architecture-dependent floating-point paths, and unstable constraint sorting.
- Run 10,000 cross-platform replay seeds in CI and fail on the first unequal hash.
Why interviewers ask this: This checks practical deterministic simulation work rather than a vague fixed-point answer.
I would eliminate runtime PSO creation by collecting, baking, and warming the actually reachable permutations.
- Correlate hitch markers with pipeline creation calls and shader keys in PIX captures.
- Generate a stable PSO cache from automated playthroughs, then prewarm the next level set during loading.
- Track cache miss rate and require no creation above 2 ms during a 30-minute traversal.
Why interviewers ask this: This tests whether the candidate can turn first-use shader stutter into a verifiable pipeline fix.
I would derive resource lifetimes from the graph and alias non-overlapping transient allocations.
- Visualize pass lifetimes to find textures kept alive by accidental reads or overly broad barriers.
- Alias equal-class resources and lower resolution only for passes whose quality metric remains within target.
- Verify peak committed VRAM below 3.6 GB across 20 stress cameras, including capture overhead disabled.
Why interviewers ask this: This probes render-graph lifetime reasoning and evidence-based memory reduction.
I would classify the lighting cost as bandwidth, shading, geometry, or synchronization with a GPU capture.
- Compare pass duration, occupancy, texture bandwidth, and pixel count while holding the camera fixed.
- Test light culling, shadow resolution, and material complexity one variable at a time against image diffs.
- Accept a change only if lighting stays under 4 ms at P95 on the minimum-spec GPU.
Why interviewers ask this: This assesses disciplined GPU diagnosis against a concrete target.
I would profile allocation call stacks and eliminate churn on the frame-critical paths before tuning collection.
- Tag allocations by subsystem and rank sites by bytes per frame and lifetime, not only total bytes.
- Replace transient containers with frame arenas, pools, or caller-owned buffers with explicit reset points.
- Soak for 2 hours and gate both zero unexpected frame allocations and P99 pause below 2 ms.
Why interviewers ask this: This tests allocator literacy and proof that the player-facing pauses are gone.
I would confirm external fragmentation by inspecting free-block sizes rather than treating total free memory as capacity.
- Dump allocator bins and allocation tags at failure time.
- Move large textures to a dedicated page allocator and compact only relocatable resources.
- Reproduce 50 level transitions with the largest free block above 256 MB.
Why interviewers ask this: This tests diagnosis and containment of fragmentation.
I would measure work, wait, and scheduler overhead per worker before changing task granularity.
- Use Tracy zones to expose dependency stalls, lock contention, and idle gaps.
- Batch sub-50 microsecond jobs and split one dominant serial dependency.
- Require at least 5.5 times speedup on the same 10,000-entity workload.
Why interviewers ask this: This checks evidence-based parallel scaling work.
I would make ownership violations observable and force the schedule to vary under a deterministic workload.
- Run ThreadSanitizer where supported and add generation checks to animation handles.
- Record job dependencies and seeds, then inject randomized yields around suspected writes.
- Keep a 12-hour stress test that reproduces zero corrupt states across 3 builds.
Why interviewers ask this: This tests reproducible diagnosis of a timing-sensitive runtime fault.
I would replace it unless a linearizability test proves correctness and profiling proves the lock matters.
- Model producer and consumer counts plus overflow behavior explicitly.
- Run randomized histories under sanitizer and verify every event ID exactly once.
- Compare P99 frame time against a bounded mutex queue before accepting complexity.
Why interviewers ask this: This probes judgment around risky lock-free code.
I would keep authoritative fixed-step states and interpolate a separate render transform.
- Store previous and current simulation poses with a frame accumulator.
- Extrapolate only bounded cosmetic motion, never collision authority.
- Test camera-relative jitter below 0.2 pixels during 10-minute captures.
Why interviewers ask this: This tests separation of simulation and presentation clocks.
I would enable swept continuous collision only for fast bodies that cross a size-based threshold.
- Compute motion per step against the smallest relevant collider thickness.
- Use speculative contacts or shape casts for flagged bodies, not every object.
- Measure zero tunneling in 100,000 shots with physics below 2.5 ms.
Why interviewers ask this: This checks targeted collision robustness under budget.
I would tier simulation fidelity by relevance and batch spatial queries before changing behavior quality.
- Update distant agents at 5 Hz while preserving near-player reactions at 30 Hz.
- Share flow fields and broad-phase neighbor grids instead of per-agent path searches.
- Validate 3 ms P95 plus unchanged collision and arrival metrics in 3 crowd scenes.
Why interviewers ask this: This evaluates scalable game AI with player-facing gates.
I would rebuild dirty navigation tiles asynchronously and publish them at a safe simulation boundary.
- Mark only tiles touched by the 20 changed obstacles plus required neighbors.
- Keep queries on the old immutable mesh until the replacement tile is complete.
- Gate main-thread publish below 0.5 ms and path invalidation within 2 ticks.
Why interviewers ask this: This checks incremental navigation updates without gameplay hitches.
I would remove synchronized full-tree evaluations and schedule bounded work across frames.
- Profile node visits to identify expensive perception and path requests.
- Use event-driven aborts plus staggered services keyed by entity ID.
- Cap AI work at 2 ms while keeping reaction latency below 100 ms.
Why interviewers ask this: This tests control of bursty AI evaluation.
I would combine visibility-based update rates, pose sharing, and measured bone LOD.
- Share poses for compatible crowds and evaluate unique leaders only.
- Reduce distant skeletons to required skin and socket bones at 15 Hz.
- Preserve hero input-to-pose latency while holding total animation below 5 ms.
Why interviewers ask this: This assesses animation optimization without visible regressions.
Locked questions
- 21
A root-motion attack drifts 35 cm from server collision over 2 seconds; how do you reconcile it?
iacgameplayphysics - 22
A save snapshot of 50,000 objects takes 120 ms on the game thread; how do you redesign it?
game-designsnapshotconcurrency - 23
A reflection-based serializer adds 18 MB and 30 ms to load; what boundary would you replace?
serialization - 24
A gameplay event bus dispatches 90,000 events per frame and costs 4 ms; what would you change?
gameplaytiming - 25
A GAS effect stack produces 3 different outcomes after 40 buffs; how do you make evaluation stable?
gas - 26
A 4-player local game has 12 input devices and hot-plug bugs; how do you model input?
game-designgameplay - 27
A camera update adds 22 ms of motion-to-photon latency at 120 fps; where do you move it?
latency - 28
A quaternion camera flips near 89 degrees pitch in 2 modes; how do you fix the representation?
math - 29
A floating-origin world shows 6 cm physics jitter at 80 km; how do you preserve precision?
physics - 30
A procedural terrain seam differs by 3 cm between 2 adjacent chunks; how do you guarantee continuity?
- 31
A renderer submits 22,000 draw calls and spends 9 ms on the render thread; what is your reduction plan?
renderingconcurrency - 32
A mobile scene has 4.5 times overdraw and runs at 42 fps instead of 60; what do you change?
scene-management - 33
A shader has 180 permutations and adds 12 minutes to builds; how do you cut variants safely?
renderingbuild - 34
A temporal upscaler ghosts for 8 frames behind fast weapons; how do you debug history rejection?
weaponstiming - 35
A shadow pass costs 6 ms for 14 lights in a 60 fps scene; what budget policy do you apply?
scene-management - 36
A Vulkan renderer deadlocks once every 500 launches after adding async compute; how do you investigate?
lockingasync - 37
A GPU particle system handles 1 million particles but readback stalls CPU for 5 ms; what boundary changes?
renderingsystem-design - 38
A meshlet culling path is slower than CPU culling below 3,000 objects; how do you choose the crossover?
- 39
A texture streamer misses 120 MB of requests during a 90-degree turn; how do you prevent visible mips?
rendering - 40
A 4K UI pass consumes 2.2 ms because 700 widgets rebuild each frame; how do you fix invalidation?
timing - 41
A gameplay module takes 14 minutes to relink after 1 header changes; how do you cut iteration time?
gameplayiteration - 42
A 25-person team sees 18 percent of crashes in engine lifetime code; what concrete review gate do you add?
- 43
Two engine teams propose 3 incompatible entity handle types with 8 weeks to integration; what do you decide?
- 44
A junior change raises frame P99 from 17 to 24 ms 2 days before a milestone; how do you handle it?
milestonessoft-skillstiming - 45
A new allocator improves average frame time by 0.4 ms but causes 30 ms spikes every 20 minutes; do you ship it?
timing - 46
A C++ plugin crashes in 7 percent of hot reloads after an ABI change; what boundary do you enforce?
tooling - 47
An asset cooker uses 32 cores at only 28 percent and takes 70 minutes; how do you restructure dependencies?
dependenciesassets - 48
A crash dump from 1 of 50,000 sessions lacks symbols for 3 engine DLLs; how do you make it actionable?
sessions - 49
A deterministic replay file grows to 600 MB for 30 minutes; how do you reduce it without losing diagnosis?
simulation - 50
A 10-minute benchmark improves 8 percent after an optimization, but 2 of 12 scenes regress; what is your release gate?
optimizationscene-management - 51
At 140 ms RTT, a predicted sprint drifts 70 cm before correction; how would you implement reconciliation?
agilereactiac - 52
A 100-player match has an 80 Kbit/s per-client replication cap at 30 Hz; how would you allocate it?
replicationgameplay - 53
A player with 180 ms latency reports valid hits rejected by a 60 Hz server; how would you design lag compensation?
designnetworkinglatency - 54
Rollback diverges after 240 frames only between x86-64 and ARM64 builds; how do you find the nondeterministic operation?
rollbackbuildnetworking - 55
Vehicle steering becomes jerky at 3 percent packet loss and 20 Hz snapshots; what recovery scheme would you use?
networkingsnapshot - 56
A 64-player firefight pushes a 30 Hz server tick from 18 ms to 42 ms; what would you change first?
networkinggameplay - 57
One inventory item duplicates per 50,000 reconnects after a purchase response is lost; how do you remove the race?
inventory - 58
A 5v5 dedicated server dies and players must resume within 12 seconds; what state and protocol do you need?
gameplaytyping - 59
A 40,000-player ranked queue reaches 95-second P95 while skill spread must stay below 120 rating points; how would you tune matchmaking?
spreaddata-structuresgameplay - 60
A 6-player party splits in 0.4 percent of concurrent allocations; how would you make placement atomic?
concurrencygameplay - 61
A hacked client sends 240 aim updates per second to a 60 Hz server; how do you stop the exploit without hurting legitimate players?
gameplay - 62
A new movement detector raises false bans from 0.02 to 0.7 percent across 3 platforms; how do you repair it?
cross-platform - 63
Four seconds of packet loss creates an 8 MB reliable backlog that delays movement; how would you redesign the channels?
backlognetworking - 64
A late joiner needs 35 MB of world state but must become playable within 5 seconds; how would you build the snapshot path?
snapshotbuild - 65
Snapshot arrivals vary from 35 to 120 ms in a 60 Hz fighting game; how do you size interpolation without adding constant latency?
game-designnetworkingsnapshot - 66
A seasonal update changes 18 GB of a 70 GB install although artists edited only 900 MB; how do you reduce the patch?
- 67
A CDN serves 2 content revisions during a 10-minute rollout; how should the client use manifests?
- 68
A live content release breaks 7 percent of quests 20 minutes after launch; how do you roll it back without corrupting progress?
- 69
Version 12 must load 8 years of save files while replacing a 32-bit item ID with a GUID; how would you migrate them?
persistence - 70
Cloud and local saves both advance by 3 checkpoints while offline on 2 devices; how do you resolve the conflict?
checkpoint - 71
A balance hotfix must reach 2 million sessions in 15 minutes while 4 client builds remain online; how do you version the data?
sessionsbuild - 72
A 12 GB DLC adds quests that reference base-game assets, but uninstall must leave every old save loadable; where is the boundary?
game-designassets - 73
User mods can run scripts, but a bad mod must not read account tokens or stall a 16.67 ms frame; how would you sandbox it?
tokenstiming - 74
A 48 GB build must become playable after a 6 GB download on 3 stores with different chunk rules; how do you lay it out?
build - 75
A 25 MB hotfix changes one quest graph but its dependency closure pulls 4 GB; how do you stop accidental content coupling?
dependenciesclosures - 76
Driving at 160 km/h causes 300 ms stalls when open-world cells cross a 220 MB/s storage limit; how would you schedule streaming?
streaming - 77
A 16 GB PC build reaches 13.8 GB RAM after 45 minutes of world traversal; how do you separate cache growth from a leak?
cachingbuild - 78
An 8 GB GPU exceeds its VRAM budget by 1.6 GB when entering a dense city; how do you prevent residency thrash?
rendering - 79
A door transition must fall from 9 seconds to 3 seconds on a 100 MB/s hard drive; what would you put on the critical path?
schedulingcommunicationstate-machine - 80
Oodle decompression consumes 7 ms of an 11 ms frame during fast travel; how do you balance IO, CPU, and latency?
latencytiming - 81
Open-world music clicks every 12 minutes when 96 kHz stems stream beside textures; how would you isolate audio IO?
rendering - 82
After 30 suspend and resume cycles, a console returns corrupted reads from 1 of 400 streamed packages; how do you investigate?
- 83
World streaming leaves 2.4 GB free but cannot allocate a contiguous 256 MB GPU upload heap after 6 hours; what would you change?
streamingrenderingdata-structures - 84
Entering any new biome causes 70 ms shader hitches on the first 15 materials; how do you integrate PSO preparation with streaming?
renderingstreaming - 85
Unloading 1 world-partition cell destroys an NPC still referenced by 14 active quests; how would you model ownership?
ownershippartitioning - 86
Fast travel across 20 km spikes RAM by 6 GB because source and destination cells overlap; how would you bound the transition?
state-machine - 87
A console mode targets 120 fps but CPU frame time is 10.5 ms while GPU is 7 ms; what platform-specific compromise would you ship?
renderingtiminggameplay - 88
A mobile game starts at 60 fps but falls to 38 fps after 12 minutes on a 35 C device; how do you design thermal scaling?
scalingdesigngame-design - 89
A PC patch causes shader crashes on 2 of 18 supported driver families while the other 16 gain 9 percent GPU time; what do you ship?
rendering - 90
Certification requires suspend-to-play within 2 seconds after 50 cycles, but your game takes 4.6 seconds; what do you change?
game-design - 91
A console has a fixed 12 GB title budget, but the PC high preset uses 15.5 GB in the same scene; how do you enforce parity without identical assets?
scene-managementassets - 92
A mobile store caps the initial download at 200 MB, but localization and tutorial assets total 310 MB for 8 languages; how do you package it?
assets - 93
Cross-play matches put 120 Hz mouse users against 60 Hz controllers, and controller win rate drops by 14 percent; what runtime changes are defensible?
- 94
A platform compliance test finds UI clipped at 150 percent text scale in 23 of 180 screens; how do you fix it without destabilizing launch?
cross-platform - 95
A teammate's refactor increases replication CPU from 3.2 to 6.8 ms 4 days before content lock; how do you handle the code and the review?
soft-skillsrefactoringreplication - 96
Three teams need incompatible save schemas in 6 weeks, and 28 existing types already serialize directly; what architecture decision would you drive?
serializationschema - 97
An on-call engineer mitigates a 22 percent disconnect spike by disabling reconnect, which risks duplicate rewards; what do you do in the first 30 minutes?
on-call - 98
A studio wants to replace its asset streamer in 4 months, but no one can state why 6 shipped levels miss deadlines; what code plan do you propose?
estimationassets - 99
Two senior engineers disagree on fixed-point versus floating-point rollback with a prototype due in 10 days; how do you resolve the code decision?
conflictprototypesrollback - 100
A 14-engineer team has 37 crash fixes waiting, and the top 3 signatures cause 61 percent of sessions lost; how do you organize the technical work?
sessions