Skip to main contentSkip to contact
Ocean View Games
Blog header banner

Taking Over an Existing Unity Project: Our First Checks

David Edgecombe

By David Edgecombe

·5 min read

What happens when an experienced Unity team inherits a project, from safe branching to playthroughs and real-device checks.

Start by protecting the working project

When we take over an existing Unity project, our first job is not to change it. We create a new branch so we have a safe point to return to. Then we open the project in the editor version it was built for, rather than immediately moving it to whichever Unity version happens to be newest. This matters because an older game may have a fragile combination of packages, assets and scripts that only worked together in a particular environment. Changing all those pieces at once makes it harder to work out why something has broken. Whether the project should move to a newer version at all is a separate decision, which we cover in when to migrate your Unity project.

Before promising a delivery date, we also need the repository, the correct editor version and access to the assets and packages the project expects. If something is missing, we document that as an open issue. A video of the game working is useful context, but it is not the same as a build we can reproduce ourselves.

A branch is a practical safety measure, not a full backup strategy on its own. We check the repository and access arrangements as part of the handover, so the team knows what can be restored if the investigation uncovers a problem.

Get the project compiling before chasing polish

Once the original version opens, we tackle blockers in a deliberate order. Code that will not compile is a critical issue because it prevents us from checking the rest of the game properly. After that come broken package dependencies, missing assets, shaders, obsolete APIs and the less obvious warnings introduced by old tooling.

It is tempting to tidy every warning as soon as it appears. That can cause unnecessary changes before we understand the original behaviour. We first separate issues that stop the project running from issues that can be assessed once the game is playable. A small list stating what failed, what was changed and what is still unknown is more useful than claiming the project has been 'fixed' because the Console window is quiet.

Package problems deserve particular care. The more third-party dependencies a Unity project has, the more compatibility paths there may be to check. An old shader may need attention after a render pipeline change. A plugin might work in the editor but fail on Android or iOS. We investigate each affected dependency rather than assuming that the package manager reporting success means the whole project is ready.

Play the whole game, not just the opening screen

After the critical issues are resolved, we do a full gameplay playthrough. That is part of our normal approach to checking an inherited game. The goal is to confirm that it still behaves like the version the client expects, and to spot failures that a compilation check cannot reveal.

A game can launch and still have a broken level transition, incorrect reward, missing effect, input problem or piece of save-state behaviour that only appears later. If the client can provide a known-good build, it becomes a useful reference for comparing the new project against the old one. Where possible, we keep a record of the routes we tested and any differences we find.

For larger games, 'full playthrough' needs a sensible scope agreed with the client. A huge content library cannot always be exhaustively covered in a short initial audit. We distinguish representative testing from complete coverage and make the remaining risk visible instead of implying every possible player path has been checked.

Move on to real devices

The Unity editor is not the finished product. Once gameplay is in a stable state, we move to builds on the intended devices. Mobile projects need real phones and tablets, especially when advertising, purchases, touch input or platform-specific SDKs are involved. Browser and PC builds have their own environment constraints.

We look for differences in performance, visuals and behaviour, and we record the device and build used for each check. An old project may contain assumptions about graphics APIs or input that only show up outside the editor. If a client has a specific minimum device or operating-system requirement, that needs to be part of the test plan rather than something discovered shortly before release.

Our work on When Ski Lifts Go Wrong is a useful example of why a large, older project needs careful migration and validation. We brought the Unity 2018 project forward to Unity 6 and adapted it for phones and tablets, using side-by-side play comparisons with the original to confirm that gameplay stayed consistent.

What a useful audit leaves behind

A good takeover assessment should produce something the owner can act on: a written report, prioritised issues, performance findings where they have been measured, estimates where the scope is sufficiently clear, and a plan for the next stage. Those are the deliverables of our Unity technical audit service.

A priority list should explain not only what is wrong, but why it matters. A compiler error blocks work now; a fragile package might become a risk when an upgrade is required; a minor visual difference may be acceptable until after release. A client should be able to make an informed decision without needing to decipher a wall of technical jargon.

Some unknowns only become clear after deeper testing. We state those limitations rather than hiding them in a fixed-price promise. That is particularly important when the original developer is no longer available or the project has not been updated for several years.

Questions worth asking during handover

A client does not need to know every technical answer before making contact. A few practical details still save time: which Unity editor version was used for the last working release, who can access the repository, who owns the package licences, and whether a current build exists for comparison. If another company handled the app-store accounts, identify the account owner before planning an update. If the game relies on external servers, ask who operates them and whether the test environment is available.

It is equally useful to know what must remain unchanged. The client may care more about preserving existing levels, user progress and input behaviour than about replacing an ageing but stable subsystem. Capture that priority early. Otherwise, a well-intentioned technical clean-up can become work the client never asked for.

Finally, ask what a successful first milestone would look like. It could be a repeatable build, a critical crash fixed or a written assessment. Choosing one clear outcome makes the initial engagement easier to scope and evaluate.

What not to promise on day one

An initial look at an inherited project is not enough to promise that every plugin can be upgraded, every shader will render identically or every historical bug can be found. Some failures only appear after a specific level, a particular save state or a test on an older phone. We can describe the checks we intend to run and the evidence we expect to gather, but the result of those checks should inform the final plan.

A useful quote distinguishes known work from unresolved dependencies. For example, restoring compilation might be relatively well understood, while replacing a discontinued platform SDK depends on what the original implementation did. Those items deserve different levels of confidence. The point is not to make a project sound difficult. It is to avoid surprising the client with hidden work halfway through delivery.