An expert second pair of eyes on your Unity codebase — finding performance bottlenecks, architectural risks, and code quality issues before they become production problems.
A Unity code review is not a style guide enforcement exercise. My reviews focus on correctness (code that does what the developer intended), robustness (code that handles edge cases and failure modes gracefully), performance (code that doesn't introduce unnecessary allocations, excessive GetComponent calls, or per-frame computation that should be cached), and maintainability (code that the next developer — or you, six months from now — can understand and modify safely).
The deliverable is a written report with findings categorised by severity (Critical, Major, Minor, Suggestion), each with a specific code reference, explanation of the problem, and a recommended fix. Critical findings are those that will cause crashes, data loss, or severe performance degradation in production. Suggestions are style or pattern improvements that are worth considering but not urgent.
I review C# Unity code, shader code (HLSL/ShaderGraph), editor scripts, and build pipeline scripts. I do not review art assets or level design unless their structure is causing technical problems (for example: a scene hierarchy that is causing excessive draw calls).
Performance problems in Unity games rarely live where developers expect them to. I've seen dozens of cases where a team spent weeks optimising rendering only to discover the real bottleneck was a string comparison in a hot loop, or a missing SerializeField causing a repeated reflection lookup. Systematic profiling with the right tools is the only reliable approach.
My performance audit process uses the Unity Profiler (CPU, GPU, Memory, Rendering, Audio modules), Frame Debugger for draw call analysis, Memory Profiler for allocation analysis and memory leak identification, and platform-specific tools (Xcode Instruments for iOS, OVR Metrics Tool for Meta Quest, RenderDoc for GPU debugging) where the target platform is known.
The audit report documents: the specific profiling methodology used, a breakdown of time and memory costs by system, the top 5–10 highest-impact bottlenecks, a prioritised remediation plan with estimated impact for each fix, and recommended monitoring metrics to track after optimisation. I typically find 30–60% performance improvement opportunities in projects that haven't been formally audited.
The most expensive bugs are the ones baked into your architecture. A game built without clear scene management conventions, with gameplay logic tangled into MonoBehaviour lifecycles, with no separation between data and behaviour, will become increasingly difficult to extend and maintain as scope grows. I've seen this pattern collapse under production pressure at every project scale from solo indie to 20-person team.
Architecture consulting typically happens at two points: at the start of a project (greenfield architecture design, technology selection, pipeline planning) or mid-project when scaling problems emerge (untangling existing systems, identifying the minimum viable refactoring path that doesn't require stopping feature development).
Topics I cover in architecture engagements: scene and GameManager patterns, dependency injection vs service locator, ScriptableObject-based event systems, data-driven design, save system architecture, addressables and content pipeline design, multiplayer architecture (Netcode for GameObjects, Mirror, Photon), and CI/CD pipeline setup with GitHub Actions or GitLab CI.
Frequently Asked Questions
How long does a code review take?
A focused review of a specific system (camera, UI, network layer) typically takes one to two days. A whole-project audit for a medium-sized game (50,000–150,000 lines of C#) takes three to five days. I'll give you a more accurate estimate after you share a brief description of the project scope and what concerns prompted the review.
Do you need access to the full project or just the code?
For a code review, the C# source files are sufficient. For a performance audit, I need the full Unity project and a device or simulator that matches the target platform. I sign NDAs before receiving any proprietary code or assets — this is standard practice for all my client engagements.
Can you help implement the fixes you identify?
Yes. Many clients engage me for a review and then retain me to implement the highest-priority fixes. This is often the most efficient path — I understand the codebase from the review, so implementation is faster than it would be cold. We'd scope and price the implementation work separately from the review.
Is this useful for solo developers or only teams?
Extremely useful for solo developers. As a solo dev you have no colleagues to catch your blind spots, and the cost of an architectural mistake is paid entirely by you. A two-hour review call with screen share and a written summary report is one of the highest-ROI investments a solo developer can make before entering production.
Last updated: March 2026