Ocean View Games

Posted on Sep 4 Originally published at oceanviewgames.co.uk

The True Cost of Game Development Outsourcing

#gamedev #unity3d #programming

When studios compare outsourcing options, the conversation almost always starts - and too often ends - with hourly or daily rates. A provider quoting half the rate looks half the price. In practice, rate is only one variable in the cost of getting reliable, production-ready work into your game.

Except the maths is wrong. Or rather, it is incomplete.

The hourly rate is the sticker price, not the total cost of ownership. The real cost of outsourcing includes communication overhead, ramp-up time, quality variance, IP risk, timezone friction, management burden, and the cost of getting it wrong. These hidden costs can erase much of the apparent saving from a lower rate - or make a more expensive partner cheaper once delivery risk and internal time are included.

We write this from a particular vantage point. Ocean View Games is a UK-based co-development partner. We have sat on both sides of the outsourcing relationship - as the team being outsourced to, and as developers who have worked alongside outsourced teams on large studio projects. We have seen what works, what does not, and what the actual cost drivers are.

The Visible Costs

Let us start with the costs that do appear on invoices. These are the numbers procurement teams compare.

Hourly or Daily Rates

The direct cost of developer time is the easiest number to compare, but quoted rates are shaped by more than geography. Seniority, specialism, contract length, whether project management is included, and how much responsibility the partner is taking all affect the number.

When comparing providers, normalise the quote before drawing conclusions:

Question	Why It Matters
Who will actually work on the project?	A senior-led team and a junior-heavy team are not equivalent purchases
What is included in the rate?	Production, QA, technical leadership, meetings, and support may be inside or outside the quote
How much working-day overlap is there?	Real-time collaboration changes iteration speed
Is the scope deliverable-based or time-based?	A fixed deliverable transfers different risk than staff augmentation
What happens after delivery?	Documentation, handover, warranty fixes, and ongoing support affect total cost

The useful comparison is not "who has the lowest hourly rate?" It is "what will it cost us to get this scope integrated, accepted, and maintainable?"

Project Management and Coordination

Most outsourcing providers include a project manager in their rates, but this person manages the outsourced team's internal workflow - not the integration with your team. You will still need someone on your side to manage the relationship, review deliverables, and translate requirements. Budget explicit internal time for coordination rather than assuming the provider's project manager removes the need for client-side ownership.

Tooling and Infrastructure

If the outsourced team needs access to your version control, project management tools, CI/CD pipeline, and communication platforms, there may be additional licence costs. Some providers use their own tools, which creates a handover problem later.

The Hidden Costs

This is where the real total cost emerges. These costs do not appear on any invoice, but they are real and measurable.

1. Communication Overhead

Communication is the single largest hidden cost in outsourcing, and it scales non-linearly with team size and cultural distance.

Shared language and context - even when everybody communicates well, phrases like "the inventory should feel snappy" are ambiguous. External teams usually need more explicit acceptance criteria because they have less product context. Writing and maintaining that context takes time.

Communication norms - teams differ in how quickly they challenge requirements, surface uncertainty, and escalate blockers. The important factor is not nationality; it is whether the working relationship makes uncertainty visible early.

Asynchronous communication cycles - large timezone gaps can turn a quick clarification into a next-day response. That is manageable for self-contained work, but expensive when a feature needs rapid iteration with designers and engineers.

Practical impact: Track coordination time during the first few weeks. If senior people on your side are spending several hours a week rewriting briefs, chasing clarifications, or reviewing avoidable rework, include that time in the effective cost of the engagement.

2. Ramp-Up Time

Every new developer, whether in-house or outsourced, needs time to understand your codebase, tools, conventions, and domain. The question is how long this ramp-up takes and who pays for it.

Ramp-up is driven much more by relevance than postcode. A team that already knows your engine version, platform constraints, backend pattern, and type of codebase can start making useful changes sooner. A team learning all of those things at once will need more review and context before it can work independently.

That difference is worth modelling explicitly. Ask every provider what the first two weeks look like, which people will be onboarding, what they need from your team, and when you should expect the first production contribution.

When we join a project as a co-development partner, we aim to make the first useful contribution quickly. Relevant experience on large Unity codebases, including David's previous work on RuneScape Mobile at Jagex and our work on Domi Online, reduces the amount of domain learning required before we can help.

3. Quality Variance and Rework

The most expensive code is code that has to be written twice.

Quality variance is the gap between what you expected and what you received. It manifests in several ways:

Code that works but is not production-ready - no comments, no tests, no adherence to your coding standards. It functions but creates technical debt that your in-house team must clean up.
Code that does not integrate - the outsourced team built a module in isolation that does not mesh with your architecture. Integration work falls on you.
Misunderstood requirements - the feature was built to specification, but the specification was interpreted differently. Rework ensues.
Missing edge cases - the happy path works; error handling, null checks, and boundary conditions do not. These bugs surface in QA or, worse, in production.

Practical impact: Measure rework as part of the engagement. Track how often delivered work is rejected, substantially rewritten, or needs unexpected integration work. A low rate is not valuable if the same feature is effectively paid for twice.

Key Takeaway: A lower rate is not automatically a lower cost. Calculate the effective cost of usable, production-ready output, including the time your own team spends getting it there.

4. Timezone Friction

Timezone differences affect more than communication speed. They affect your ability to:

Iterate quickly - game development is iterative. "Try this, see how it feels, adjust" is the core workflow. When each iteration cycle takes 24 hours instead of 30 minutes, the feedback loop breaks.
Respond to emergencies - your live game is down, and the team that wrote the server code is asleep. How long can you wait?
Participate in standups and reviews - if overlap is minimal, either your team or theirs is attending meetings outside working hours. This is unsustainable.
Maintain team cohesion - when people never interact in real-time, they do not form working relationships. The outsourced team becomes "them," not "us."

The overlap question: There is no magic number of shared hours. The right amount depends on the work. A self-contained asset task may need very little overlap; embedded engineering, debugging, and design iteration benefit from a reliable daily window where the relevant people can talk in real time. Define that window before the engagement starts.

5. Intellectual Property Risk

When you outsource game development, you are sharing your source code, design documents, art assets, and business strategy with an external party. This creates IP risk that must be managed through legal, technical, and procedural controls.

Legal protections:

Non-Disclosure Agreements (NDAs) - essential, but enforceability varies by jurisdiction. An NDA governed by UK law is straightforward to enforce in the UK. Enforcing it in a jurisdiction with different IP protections is more complex and expensive.
Work-for-hire agreements - ensure that all code, assets, and documentation produced are owned by you, not the outsourcing provider. This is standard but must be explicit.
IP assignment clauses - separate from work-for-hire, these ensure any background IP contributed by the provider is licensed to you appropriately.

Technical protections:

Compartmentalised access - the outsourced team should only access the repositories and systems they need. Not your entire codebase.
Code review gates - all contributions must pass review by your in-house team before merging.
Secure development environments - VPN access, no local code storage, audit logging.

Practical risk assessment: For most professional outsourcing relationships, IP theft is rare. The greater risk is IP leakage through poor security practices (unencrypted laptops, shared credentials) rather than malicious intent. Proper onboarding and security protocols mitigate this effectively.

6. Management Burden

Managing an outsourced team takes more of your time than managing an equivalent in-house team. This is your time - the most expensive time in the project.

Responsibilities that fall on you:

Writing more detailed specifications (because you cannot explain context verbally)
Reviewing code and deliverables more carefully (because the team is less familiar with your standards)
Mediating between in-house and outsourced teams (integration points, merge conflicts, architectural decisions)
Handling administrative overhead (invoicing, contracts, access management)

Practical impact: Put a value on the client-side management burden. If your technical lead spends a day each week coordinating external work, that day belongs in the cost model just as surely as an invoice does.

Comparing the Models: Offshore vs Nearshore vs UK-Based

Offshore (Large Timezone Gap)

Often a good fit for: Well-defined, self-contained work with clear acceptance criteria and a workflow designed for asynchronous delivery.

Watch for: Slow feedback loops on work that depends on frequent design or engineering decisions.

Nearshore (Meaningful Working-Day Overlap)

Often a good fit for: Ongoing support where real-time collaboration matters but the client is comfortable working across jurisdictions and organisations.

Watch for: Assuming proximity guarantees process fit. Team seniority, communication, and ownership still matter more than the label.

Local / Same-Timezone Partner

Often a good fit for: Embedded engineering, architectural decisions, workshops, rapid iteration, and work where the external team must behave like part of the internal team.

Watch for: Paying a premium for proximity when the work is actually self-contained and does not benefit from it.

Key Takeaway: Geography is a constraint, not a quality score. Compare the collaboration model to the work you need done, then compare total cost rather than assuming one region is inherently better than another.

What to Look for in an Outsourcing Partner

Regardless of geography, the factors that predict outsourcing success are:

1. Relevant Portfolio

Have they built games like yours? Not just "Unity games" - your platform, type of codebase, and technical constraints. When we partnered with Domi Online, experience with large live-game systems and David's previous work on RuneScape Mobile at Jagex meant we were familiar with many of the architectural problems from the start.

2. Communication Quality

Test this before signing. How quickly do they respond to your initial enquiry? How clearly do they explain their process? Do they ask good questions about your project, or do they just quote a rate? The pre-sales interaction is a reliable predictor of the working relationship.

3. Process Maturity

Do they use version control? Do they have a code review process? Do they write tests? Do they use project management tools? These are not "nice to haves" - they are the minimum requirements for professional software development. Be wary of any provider that cannot clearly articulate their development process.

4. References from Similar Projects

Ask for references and actually call them. Ask specifically about:

Ramp-up time
Communication quality
Code quality on delivery
How they handled disagreements or scope changes
Whether the reference would hire them again

5. Team Stability

Will the same developers work on your project throughout, or will they be rotated to other clients? Developer rotation resets the ramp-up clock every time. Contractually binding named developers to your project is worth negotiating.

6. Clear IP Agreements

The contract should explicitly state:

You own all code, assets, and documentation produced
The provider will not reuse your code on other projects
Background IP (frameworks, tools) is licensed to you
Source code is delivered incrementally, not only at project end

Making the Decision

Here is a practical framework for choosing your outsourcing model:

If your priority is...	Consider...
Lowest possible cost for well-defined tasks	Offshore with detailed specifications
Balance of cost and collaboration	Nearshore with daily overlap
Maximum integration and minimum friction	UK-based co-development partner
Surge capacity for a specific phase	Short-term co-development engagement
Long-term ongoing support	Retained co-development relationship

The worst outcome is not choosing the "wrong" label - it is choosing a model without accounting for the hidden costs. A higher-priced engagement can be cheaper overall if it reduces internal rework and protects the delivery schedule.

How We Approach Co-Development

At Ocean View Games, our co-development model is designed to minimise the hidden costs described above:

Embedded integration - we join your Slack, attend your standups, commit to your repo. We operate as an extension of your team, not a separate entity.
UK-based, UK timezone - we have a full working-day overlap with UK clients, which makes real-time pairing, debugging, and iteration straightforward.
Senior developers only - our experience spans David's previous RuneScape Mobile work at Jagex and our Domi Online work, alongside mobile, educational, and legacy projects.
Clean handoff - all code is documented, commented, and follows your style guide. When the engagement ends, your team picks up without confusion. No lock-in.
UK legal jurisdiction - our contracts use English law, which can simplify procurement for UK clients.

We are not the cheapest option on a rate card. We are, for many studios, the most cost-effective option when total cost of ownership is considered.

Calculating Your True Cost

Before engaging any outsourcing partner, build a total cost model:

Direct cost - hourly rate x estimated hours
Ramp-up cost - weeks to productivity x weekly rate (producing minimal output)
Communication overhead - your team's time spent on specifications, reviews, meetings, and coordination
Rework budget - the cost of rejected work, integration fixes, and substantial rewrites; estimate this from the provider's references or a paid trial rather than a generic percentage
Management burden - your lead's time redirected to coordination (value this at their effective rate)
Risk premium - the cost of delay if things go wrong (missed market window, delayed revenue)

Add these together. Compare the totals, not the hourly rates. The answer may surprise you.

Use our game development cost estimator to build a baseline budget, then layer these outsourcing-specific costs on top.

DEV Community