Game Developer Interview Questions 2026

Last updated: October 10, 2026

By Devin Hornick, Co-Founder, KORE1

Good game developer interview questions in 2026 make a candidate read a frame they didn’t profile, tune a jump without touching the art, and explain who wins a shot fired at 120 milliseconds of latency. Trivia about virtual destructors tells you who studied. Shipping a game is a different test.

A console studio in Irvine hired a senior Unreal engineer two years ago who had the cleanest technical interview their lead had ever run. Vtables, move semantics, cache lines, the difference between a TArray and a TSet. All correct. All fast.

His first ticket was a traversal sequence running at 21 milliseconds a frame on PS5 against a 16.67 millisecond budget.

He spent eleven working days on shaders.

The GPU was finishing in about 14 milliseconds. It was never the problem. The game thread was sitting at 19, because roughly 1,400 actors in that streaming cell were ticking every frame whether anybody could see them or not. A mid-level engineer on the same team found it in an afternoon with Unreal Insights, turned off tick on about 900 of them, and moved on. Nobody had asked the senior hire to read a capture during the loop. Nobody thought of it. He’d been interviewed for C++, and C++ was never what the job was testing.

What follows is the question set we hand studios once a game developer staffing search reaches the panel. It skips some ground on purpose. Engine-specific screening already lives elsewhere on our site. World Partition, Nanite, Lumen, and the Blueprint-versus-C++ split are covered in our guide to hiring Unreal Engine developers. The mobile, PC and console, and XR split inside the Unity pool, with comp for each, is in the Unity hiring guide. Language-level C++ screening sits with our C++ hiring guide. This piece is engine-agnostic. It’s the material that tells you whether somebody has shipped.

Fair warning about where I sit. We get paid when you hire through KORE1, so I have reasons to make interviewing sound harder than it is. Take the loop and skip us if it works. I’d honestly rather you did that than run a pleasant panel, hire on charm and C++ trivia, and find out at your first certification submission.

What a Game Developer Actually Gets Hired to Do

A game developer is a software engineer who builds the systems a game runs on, gameplay, rendering, physics, networking, tools, or the engine itself, under a hard real-time constraint. Every frame has a budget measured in milliseconds, and the player notices the moment you overspend it.

That budget is the whole reason the interview has to be different from a general software loop. A web request that takes 40 extra milliseconds is a slightly slow page. A frame that takes 40 extra milliseconds is a visible hitch in the middle of a boss fight, and it ends up in a Steam review.

Some numbers before the questions. Federal wage data doesn’t track game developers separately, so the closest occupation is software developers, whose median pay was $135,980 in May 2025 according to the Bureau of Labor Statistics, with the broader developer, QA, and tester group projected to grow 10 percent from 2025 to 2035, about 106,100 openings a year. Games run their own cycle inside that. The GDC 2026 State of the Game Industry survey of more than 2,300 professionals found 28 percent had been laid off in the past two years, 33 percent among US respondents. Unreal was the primary engine for 42 percent, Unity for 30.

So the pool is deep right now. Deep isn’t the same as easy. A bigger pool means more polished resumes and more candidates who interview well on the parts of the job that are easy to rehearse. We’ve placed technical talent for more than twenty years across upward of thirty metros, and our placements hold at 92 percent through the first twelve months. In games, almost every early exit we’ve seen traces back to the same thing. The loop tested what was easy to grade. Comp bands live on the hub page and in the hire guides above. Not here.

The Frame Budget Round

Start with arithmetic. It takes ten minutes and it sorts people faster than anything else in this piece.

The second row is the trap. In Unreal and most modern engines the game thread, render thread, and GPU work on different frames in a pipeline, so the frame costs roughly whatever the slowest one costs, not the sum. Somebody who adds the three numbers together has read about frame budgets. Somebody who points at the slowest one has fixed one.

“We target 60 on console. A frame takes 21 milliseconds. Game thread 19, render thread 12, GPU 14. Where do you start?”

Game thread. Obviously. Except it isn’t obvious to a surprising number of senior candidates, because “performance” in their head means rendering. Strong answers go straight to what’s running on the game thread and ask how many things are ticking. Better ones ask what changed since the last build that hit budget, which is the question an engineer who has lived through a milestone asks first.

“Average frame time is fine. Players are still complaining about stutter. What are you looking for?”

Here you want somebody who talks about the worst frames rather than the average one. The 1 percent lows. Frame time spikes. On a Unity project the first suspect is garbage collection, from string concatenation in an Update loop, LINQ in hot paths, or boxing that allocates every frame, and a good candidate will mention the incremental garbage collector and then tell you it doesn’t excuse allocating. On PC, in either engine, shader compilation hitches are the other usual answer, with pipeline cache precaching as the fix. Asset streaming stalls come third. Anybody who says “lower the settings” stops the round.

“You’ve got 1,400 actors ticking. What do you do?”

That’s the Irvine story, as a question. Turn tick off on everything that doesn’t need it. Tick less often based on distance or visibility. Batch similar objects into one manager that updates them together. Move work off per-frame entirely and onto events. A candidate who has shipped a dense open area will reach for at least two of those without prompting, and will probably have an opinion about which one their designers hated.

Hand Them a Capture, Not a Whiteboard

Remember the engineer who spent eleven days on shaders? This is the round that would have caught it, and it costs you one screenshot.

Pull a real profiler capture from your own game. Unreal Insights off a PS5 devkit, a Unity Profiler frame from a mid-range Android phone, a PIX capture from an Xbox Series S, whatever you’ve got. Give it to the candidate with twenty minutes on the clock and ask what they’d look at first. Then be quiet, which is honestly the hard part for most hiring managers I know.

People who’ve shipped tend to look at the timeline before any number on it, hunting for the spot where the render thread sits idle for 3 milliseconds waiting on the game thread, because a stall like that is usually cheaper to fix than a slow function. A lot of them also ask how you took the capture. I love that question. Development build or shipping? On the console, or on a workstation with an RTX 4090 in it? A Series S runs on 10 GB of memory and a much smaller GPU than a Series X, and anybody who has shipped on one has been fooled by a PC capture at least once.

Graphics seat? Use a RenderDoc frame instead and ask about overdraw, draw calls, and which pass costs the most. Live-service seat, there’s a second artifact further down I like even better. Neither one is homework. They’re sharing a static image over Zoom or sitting across from you, and you’re hearing them think out loud.

Make This Jump Feel Better

This round is for gameplay programmers, and it is the one most studios skip because nobody knows how to grade “feel.” You can grade it. It just isn’t graded on a correct answer.

Describe a jump that playtesters say feels floaty, where people keep missing ledges they think they made. Then ask what they’d change in code, without touching the animation.

Somebody who has tuned a platformer will start listing things almost before you finish. Coyote time, a grace window of roughly 100 milliseconds, six frames at 60, where a player who just ran off a ledge can still jump. Jump buffering, so a press that arrives a few frames before landing still counts. Variable height, cutting upward velocity when the button is released early. Heavier gravity on the way down than on the way up. Then, if they’re good, input latency, because a jump that responds three frames late feels floaty no matter how the arc is tuned.

A follow-up that separates the strong ones is about the designer, not the code. How do you show a designer the new jump is better? Weak answers say “they’ll feel it.” Strong answers expose every value as a tunable the designer can change live, record where players actually fail in the level, and run a short side-by-side playtest. The good gameplay engineers I’ve placed treat the designer as the customer. The ones who left early treated them as an obstacle.

One more, short. “The designer says the sword feels weak. What can you change without new animation?” Hit-stop, freezing both characters for 50 to 100 milliseconds on impact. Camera shake. A stronger sound. Controller rumble. A particle burst. Knockback on the target. Six levers, none of them art. A candidate who names four has done this.

Netcode, or Who Actually Got Shot

Senior netcode is the hardest game engineering seat we recruit for, and the interview is usually the weakest part of the search. Studios either ask textbook questions about TCP versus UDP or hand the round to a backend engineer who has never thought about a player on 120 milliseconds of ping.

A live-service team in Austin learned that one the expensive way. They hired a very good engineer out of a single-player studio for a netcode role. Strong engine programmer. Their closed beta opened with constant rubber-banding, players snapping backward a few meters every couple of seconds, and it turned out client prediction and server reconciliation were things he had read about and never built. He was a good hire for a different job. The loop had no question that would have shown it.

“A player says they got shot after they were already behind the wall. Is that a bug?”

Probably not, and the answer you want explains why. The server rewinds the world to where the shooter saw the target when they fired, checks the hit there, and the victim, who was already behind cover on their own screen, dies anyway. Valve’s Source engine made this approach widely known. The good answer names the tradeoff out loud. Favoring the shooter feels great to the shooter and terrible to the person who got hit, and somebody on the team has to decide how far back the server is allowed to rewind before high-ping players get a real advantage.

“Walk me through client-side prediction and reconciliation.”

The client moves the player immediately, the server sends back the authoritative position, and the client replays its unacknowledged inputs on top of that position when they disagree. Listen for input sequence numbers and replay. Without those, all you’ve heard is a definition. Then ask what happens when the correction is large. Smoothing over a few frames versus snapping is a judgment call, and they should have one.

“We’re building a fighting game. Rollback or delay-based?”

Rollback, almost always, since GGPO made it the expectation for the genre. The real question underneath it is determinism. Rollback only works if both machines produce identical results from identical inputs, which drags in floating-point behavior across different hardware, fixed-point math, and the debugging misery of a desync that shows up once in two hundred matches. A candidate who has shipped rollback will tell you about a desync. In detail. Probably unprompted.

Last one, about money. “What does moving our servers from 30 to 60 tick cost us?” Roughly double the simulation work and more bandwidth, per match, for the life of the game. Riot runs Valorant on 128-tick servers. A good candidate knows tick rate is a budget decision that finance has an opinion on, not just a quality slider.

Console Certification and the Week Before Submission

Every console has a requirements list a build has to pass before it ships. Sony calls theirs the TRC. Xbox calls theirs the XR requirements. Nintendo’s process is Lotcheck. Engineers who have been through it talk about it differently from engineers who haven’t, and the difference shows up in about three questions.

“Your build failed cert on suspend and resume. What’s usually behind that?” A network session that never reconnects. A save that gets corrupted because the system suspended the game in the middle of writing it. A player who signs out of their account while the game is suspended and the game doesn’t notice. Anybody who has shipped on console has a story about one of these.

“How does your save system survive the power going out mid-write?” Write to a second slot, verify it, then switch over. Never overwrite the only copy. It’s a firmware-style answer and it comes from the same scar tissue.

“We’re porting to a handheld with a fraction of the memory. Where do you look first?” Texture budgets and streaming, audio memory, and anything that was allowed to grow on PC because nobody had to care. GDC’s 2026 survey found 28 percent of developers were already building for or optimizing for Steam Deck, so this isn’t a niche question anymore. The candidate who asks for your current memory report before answering is the one you want.

Live Ops, and the Patch That Doubled the Crash Rate

This is the second artifact. Tell the candidate a patch went out on Tuesday and the crash rate went from 0.4 percent of sessions to 1.1. Give them a grouped crash report, the kind Sentry, Backtrace, or Crashlytics produces, with the top five call stacks and the build, platform, and GPU driver breakdown for each. Ask what they do in the first hour.

Strong answers sort before they read. Which stack is new since the last build? Is it one platform or all of them? One GPU vendor? One driver version? Did anything ship server-side at the same time, a config change or a store update, that would explain it without any code change at all? Then the part most people miss. Can we turn it off? A live team that ships risky features behind server-side flags can roll back in minutes instead of waiting days for a client patch to clear certification.

A mobile studio in Culver City told us their best live-ops hire answered this by asking how many players were on the old build. Turned out it was 30 percent, and the crash wasn’t in the patch at all. It was a server change that broke the old client. Twenty minutes to find. The previous candidate had spent the whole round reading one call stack.

Tools Are the Hiring Signal Nobody Reads

Ask every senior candidate, not just tools engineers, about the last tool they built for somebody who isn’t an engineer.

The answer tells you how they think about other disciplines. A level designer losing 40 minutes a day placing collision volumes by hand. An animator waiting on an engineer to hook up every new montage. A build that takes 90 minutes because content cooks serially. People who have shipped games have usually fixed at least one of these because it was in their way, and they can tell you how many hours a week it gave back.

Ask about source control too, briefly. Perforce or Unity Version Control on a project with 600 gigabytes of binary assets is a different world from Git on a web codebase, and somebody who has dealt with exclusive checkouts on a map file at two in the morning before a milestone will tell you so.

The AI Question, Asked the Right Way

You should ask about generative AI tools in 2026. Just not “do you use them.” The GDC survey found 36 percent of game industry professionals use generative AI at work, but only 30 percent at studios specifically, and 52 percent think it’s hurting the industry, up from 30 percent a year earlier. Programmers were among the most negative groups, at 59 percent. So the room is split, and whichever side of that a candidate lands on tells you very little.

Ask this instead. “Where did an AI assistant save you time last month, and where did it cost you time?” Good engineers have both answers ready. Boilerplate, test scaffolding, a first pass at an editor utility. And then the shader it confidently got wrong, or the netcode suggestion that ignored determinism entirely. What you’re screening for is judgment about when to trust the output, and whether they know your studio’s rules on generated content in a shipping build. If your studio doesn’t have rules yet, the candidate who asks about them is doing you a favor.

How to Sequence the Loop

Four conversations. More than that and you start losing senior candidates to studios that move faster.

1. First call, 30 minutes. One question. What’s the last thing you shipped, and what broke the week before it went out? It separates people who shipped from people who were on a team that shipped, and it’s hard to rehearse.
2. Technical conversation, 60 minutes. The frame budget round plus the discipline round: game feel for gameplay, netcode for multiplayer, the RenderDoc frame for graphics, the cert questions for anybody porting.
3. The artifact, 45 minutes. Your profiler capture, or the crash report for live-ops. Candidate talking, you listening.
4. Team round, 45 minutes. A designer or artist on the panel, the tools question, the AI question, and an honest conversation about the last milestone and what crunch looked like.

Take-home tests are optional and should never be unpaid. A playable game jam submission tells you less than you think. Two days of free work selects for people who have two free days, and those are rarely your strongest seniors.

If the req is still a draft, settle the posting before the loop. Our game developer JD template pins down the discipline, engine branch, and milestone these rounds are testing for.

What Strong Candidates Ask You

The good ones interview you back. Pay attention to what they pick, because people ask about whatever burned them last time.

I had a gameplay engineer in Irvine ask a creative director whether the vertical slice was locked, and when the answer was “mostly,” she asked how many times the combat system had been rebuilt. Twice. She took the job anyway, but she negotiated the start date around the next milestone review, which was smart. Others ask which engine version you’re on and whether you upgrade mid-project, since a jump from one Unreal 5.x release to the next can eat a sprint. And somebody always asks who owns the build machines, usually the person who used to get the 2 a.m. call when they fell over.

The question I’d want you ready for is simpler. “What did the last milestone look like for the team?” If you dodge it, they’ll find out from a friend who used to work there. Game dev is a small industry. Everybody knows somebody.

Things Studios Ask Us Once the Req Is Open

“Should we give game developers a take-home test or a game jam?”

Give game developers a short paid exercise or skip the take-home entirely, because unpaid game jams filter out the employed seniors you most want. A four-hour paid exercise built around your actual codebase tells you more than a weekend game jam ever will, and it respects a senior engineer’s evenings. Most of what a take-home shows, the capture and crash-report rounds show faster, in the room, while you can ask follow-ups.

“Can a strong backend engineer from outside games handle our netcode role?”

A backend engineer from outside games can own matchmaking, accounts, and telemetry, but gameplay netcode needs prediction and lag-compensation experience you should test directly. Matchmaking, accounts, inventory, and telemetry are backend work, and someone from a high-scale consumer platform like a payments or streaming company can be excellent there. Prediction, reconciliation, and determinism are game-specific. Run the “who got shot” question before assuming any of it transfers.

“How do we interview someone whose best work is under NDA?”

Ask candidates under NDA to describe the technical problem and their own decisions, not the product, since nobody needs the title name to explain a desync. Engineers can describe a frame budget fight, a desync, or a cert failure in detail without naming the title or showing a line of code. If someone can’t describe their own technical decisions at that level of abstraction, the NDA usually isn’t the reason. Shipped credits on MobyGames or the studio’s own credits page confirm the rest.

“We hire for both Unity and Unreal. Can one loop cover both?”

One loop can cover both Unity and Unreal hires, because the frame budget, capture, game feel, netcode, cert, and live-ops rounds are engine-agnostic by design. That handles roughly 80 percent of it. Swap in an engine-specific round only for the technical conversation, using Unity Profiler and garbage collection for Unity seats and Unreal Insights and the tick system for Unreal seats.

“Is it fair to ask a candidate about crunch?”

It’s fair to ask what the last milestone looked like and what they’d change about it. That’s a question about judgment, and good engineers answer it well. Asking whether they’re willing to crunch is a different question with a legal and retention cost, and in our experience the candidates who say yes too eagerly are the ones who leave first.

“Nobody on our team can run the engine round. What do we do?”

If nobody internal can run the engine round, borrow an engineer from a partner studio or lean on the technical screen we run before submitting anyone. Every senior game candidate we submit has already been through a technical screen with an engineer who has shipped commercial games, and we’ll share the notes. For a studio’s first engine hire, that screen is often worth more than the rest of the loop combined, since nobody internal can check the answers yet.

One Capture, One Clip, One Honest Conversation

If you take one thing from this, take the order. Most game dev loops don’t fail on bad questions. They fail because nobody decided ahead of time which job it was, gameplay or engine or netcode or live-ops, so the panel defaulted to the C++ questions it already knew how to grade.

Write down the first six months before you post the req. Is the game in preproduction or live? Single-player or online? One platform or four? Is there a cert submission on the calendar? Those answers pick your rounds for you.

Then put a real capture from your own game in front of every finalist. The resume won’t tell you what that twenty minutes will.

If you want help, our game development recruiting team runs this loop with studios every week, alongside our C++ developer staffing and C# developer staffing benches. A ship-date crunch usually fits contract staffing or contract-to-hire, and a platform owner who’ll be there for three titles is a direct hire search. Before the offer, check the band against our salary benchmark tool. When the req is ready, talk to a recruiter on our team and we’ll tell you straight if you’re better off running it yourself.

Related reading: where this year’s supply is coming from in our Roblox layoffs 2026 talent map, what the Epic Games layoffs put on the market, and the general software engineer interview questions guide for the non-game seats on the same team. Hiring for a casino or iGaming studio instead? That search runs through our studio and casino-side technical recruiting team.