Question 1
Difficulty: medium
How do you structure a Unity project so it stays maintainable as the game grows?
Sample answer
I try to set the project up with scalability in mind from the start, even if the first version is small. I separate gameplay logic, UI, data, and platform-specific code into clear folders and assemblies where it makes sense. I also prefer using ScriptableObjects for config data and reusable content because they reduce hard-coded values and make balancing easier later. For code organization, I keep MonoBehaviours focused on presentation and scene interaction, while core logic lives in plain C# classes that are easier to test and reuse. I also use naming conventions, consistent prefab standards, and version control rules so the team can move quickly without stepping on each other. One thing I always watch is dependency sprawl. If a script starts knowing too much, I refactor early before it becomes painful. That approach has helped me keep projects clean even as content and features scale up.
Question 2
Difficulty: hard
Tell me about a time you optimized performance in a Unity project.
Sample answer
In one project, we started seeing frame drops on mid-range mobile devices once the scene filled up with enemies, effects, and UI updates. I profiled the game first instead of guessing, and the main issues were too many allocations, expensive Update loops, and overdraw from particle and UI layers. I tackled it in layers. I replaced repeated object creation with pooling, reduced per-frame polling by moving logic to event-driven updates, and simplified some shaders and particle settings. I also combined a few UI refreshes so they only ran when data actually changed. After those changes, CPU spikes dropped noticeably and the game held a much steadier frame rate. What I learned from that experience is that performance work is most effective when it is measured, incremental, and focused on the actual bottlenecks rather than assumptions. I usually aim to build performance habits into the codebase early, not just fix issues after they appear.
Question 3
Difficulty: medium
How do you approach debugging a bug that only happens sometimes in Unity?
Sample answer
For intermittent bugs, I start by making the problem observable. I add targeted logs, capture state transitions, and try to narrow down the exact conditions that lead to the issue. If I can reproduce it, I’ll simplify the scene or create a smaller test case so I can isolate whether the problem is related to timing, object lifecycle, input, or state management. In Unity, a lot of flaky issues come from execution order, destroyed references, async loading, or objects being enabled and disabled at the wrong time. I pay close attention to those areas. I also check whether the bug is actually masking another issue, like stale data or race conditions between UI and gameplay systems. Once I identify the cause, I fix the root rather than patching the symptom. I’ve found that a calm, systematic approach saves more time than trying random changes, especially when the bug appears only under certain gameplay conditions.
Question 4
Difficulty: easy
How do you handle communication with designers and artists when implementing gameplay features?
Sample answer
I try to keep communication practical and collaborative. My goal is to translate a design idea into something that works technically without slowing the creative process. Early in a feature, I like to clarify the intended player experience, what can be flexible, and what has to stay exact. That helps avoid rework later. With designers, I’ll often prototype quickly so they can test feel and timing early rather than waiting for a polished implementation. With artists, I make sure I understand animation, VFX, and prefab requirements before finalizing code, because those details can affect how the feature behaves in-game. I also try to be transparent about tradeoffs. If a request is expensive or risky, I explain the impact and suggest alternatives instead of just saying no. In my experience, the best results come when technical constraints are treated as part of the conversation, not as an afterthought once development is already underway.
Question 5
Difficulty: hard
How would you implement a save system in Unity for a game with multiple player profiles?
Sample answer
I would design the save system around clear data separation and versioning. First, I’d define a save data model that includes profile-specific progress, settings, unlocks, and any world state that needs persistence. I’d keep that data as plain serializable C# classes so it is easy to manage and evolve. Then I’d create a save manager responsible for loading, writing, autosaving, and handling profile selection. For storage, I’d choose the format based on the game’s needs: JSON for readability and easier debugging, or a binary format if performance and size matter more. I’d also include version numbers in the save file so I can migrate old data when the structure changes. For reliability, I’d write saves atomically and protect against partial corruption. If the game is cross-platform, I’d make sure paths and platform restrictions are handled cleanly. I like save systems to be boring in the best way: dependable, easy to test, and hard to break.
Question 6
Difficulty: medium
Describe a situation where you had to meet a tight deadline on a Unity feature. How did you manage it?
Sample answer
On one project, I had to deliver a new gameplay feature before a milestone while several other systems were still changing underneath it. I handled it by breaking the work into a minimal version first and then adding polish only if time allowed. I clarified the must-have behavior with the lead and identified the dependencies that could block me, such as animations, UI hooks, and data setup. Instead of waiting for everything to be perfect, I built the feature in a way that could tolerate placeholder assets and incomplete content. That kept progress moving while other pieces were still in flight. I also checked in small increments so issues were caught early, not at the end of the week. The key was being honest about scope and focusing on the version that would actually ship. In the end, we delivered on time, and because the structure was clean, the team was able to improve it afterward without rewriting the whole thing.
Question 7
Difficulty: medium
What is your experience with Unity’s animation system, and how do you integrate it with gameplay logic?
Sample answer
I’ve worked with Unity’s animation system in a way that keeps gameplay and animation coordinated without making them too tightly coupled. I usually let animation handle presentation while gameplay code controls the actual rules and state. For example, if a character attacks, the gameplay system decides when the attack starts, when damage is applied, and when the action can be canceled, while the Animator handles the visual state and transitions. I use animation events carefully when timing needs to line up, but I avoid overusing them for core logic because they can become hard to manage if too much depends on the timeline. For more complex characters, I like using state machines or a clear controller layer so transitions stay predictable. I also test edge cases like interruption, blending, and network or input delay if relevant. My general approach is to keep the animation beautiful but not let it become the source of game rules.
Question 8
Difficulty: easy
How do you decide when to use ScriptableObjects in a Unity project?
Sample answer
I use ScriptableObjects when I want data to be reusable, editable in the editor, and separate from scene instances. They are especially useful for things like item definitions, enemy stats, ability settings, tuning values, and event channels. I like them because they make content easier for non-programmers to adjust and reduce the amount of hard-coded information in scripts. They also help when multiple systems need to reference the same configuration without duplicating it. That said, I don’t use them for everything. If the data is highly runtime-specific or tied to a single object’s transient state, a normal class is often better. I also avoid turning ScriptableObjects into a catch-all architecture where business logic starts living inside asset files. My rule of thumb is simple: use them for shared or authorable data, not for mutable runtime behavior. When used well, they make Unity projects much easier to scale and balance.
Question 9
Difficulty: medium
How do you approach building user interface systems in Unity that are both responsive and easy to maintain?
Sample answer
I like UI systems that are driven by state and data rather than scattered direct updates everywhere. My first step is usually to define clear responsibilities: the view handles presentation, the controller or presenter handles UI behavior, and the gameplay systems expose the data. That separation makes the UI easier to change without rewriting logic. I also try to minimize unnecessary refreshes, especially in dynamic menus, because UI can become surprisingly expensive if every element updates every frame. Instead, I update only when values change or when the screen state changes. For responsive behavior, I pay attention to resolution scaling, safe areas, input navigation, and controller support early, not as a late polish step. I also keep prefabs modular so menus can be reused rather than copied. In my experience, the best Unity UI feels simple to the player but is built with a lot of discipline under the hood.
Question 10
Difficulty: hard
If you joined our team and found a large amount of legacy Unity code, how would you improve it without disrupting development?
Sample answer
I would improve it gradually and in a way that protects ongoing work. First, I’d spend time understanding the existing architecture, naming patterns, and the highest-risk areas rather than jumping straight into refactoring. Then I’d identify pain points that create real cost, such as fragile systems, duplicated logic, slow iteration, or bugs that keep recurring. I usually start with small, safe improvements: adding tests where practical, cleaning up obvious abstractions, improving documentation, and reducing tightly coupled dependencies in the most active systems. If a subsystem really needs a bigger rewrite, I’d look for a way to isolate it behind an interface or adapter so the rest of the project keeps moving. I’m careful not to refactor just for elegance; the goal is to reduce risk and make the team faster. Good legacy cleanup should feel almost invisible to everyone else except that the project becomes easier to work with over time.
