Who Owns the Source Code Custom Software Is Built On? IP Explained

A business owner and developer reviewing a software contract document beside a laptop showing code

You have paid a developer to build software for your business, so surely you own it? Not always, or at least not all of it. Who owns the source code custom software is built on is one of the most important questions in any development project, and one of the most commonly overlooked. Getting it wrong can leave you unable to change providers, raise investment, sell your business or even fix a bug without someone else’s permission.

This guide explains how source code and intellectual property (IP) ownership works for software projects in New Zealand, the common grey areas and what to put in your contract so there are no surprises later. It is general information rather than legal advice, so for significant projects it is worth having a lawyer review your agreement.

Why source code ownership matters

Source code is the human-readable set of instructions that makes your software work. Whoever controls it controls what happens to the software in future. Clear ownership matters because it lets you:

  • Change suppliers if your relationship with a developer ends, without starting again from scratch.
  • Maintain and extend the software yourself or with another team.
  • Raise investment or sell the business. Investors and buyers routinely check that a company actually owns its core technology.
  • Protect your competitive advantage by stopping the same solution being resold to competitors.
  • Stay resilient if your developer stops trading or a key person leaves.

Who owns the source code of custom software under NZ law?

In New Zealand, software is protected as a literary work under the Copyright Act 1994. The general rule is that the author of a work is the first owner of copyright, with two important exceptions in section 21:

  • Employees: where an employee writes code in the course of their employment, the employer is the first owner.
  • Commissioned work: where a person commissions, and pays or agrees to pay for, the making of a computer program, and the program is made in pursuance of that commission, the commissioning party is the first owner. This is often called the “commissioning rule”.

Crucially, both exceptions apply subject to any agreement to the contrary. In other words, your contract can change the default position, in either direction. Many developers’ standard terms say the developer keeps ownership and grants the client a licence instead.

The commissioning rule also has limits. It covers computer programs but not every type of work. Some legal commentators point out that items such as written manuals or certain documentation may fall outside it, so you could own the code but not the user guide unless the contract says otherwise. And as NZ case law has shown, things become complicated when pre-existing code is incorporated into the new work. Relying on the default rule is risky; a clear written agreement is far better.

The grey areas: what you may not own

Most modern software is not written entirely from scratch. A typical application combines several layers, and ownership can differ for each:

Component Typical ownership position What to check
Bespoke code written for your project Usually yours under the commissioning rule or an IP assignment clause That the contract clearly assigns it to you
Developer’s pre-existing code, libraries or frameworks Usually stays with the developer; you receive a licence That the licence is perpetual, transferable and lets others maintain it
Open-source components Owned by their authors, used under licences such as MIT, Apache or GPL That licences are compatible with how you plan to use or distribute the software
Third-party services and APIs Owned by the provider (e.g. payment gateways, mapping, Xero) Subscription terms, costs and what happens if they change
Designs, documentation and content Depends on the contract and type of work That designs, wireframes and manuals are included in the IP clause
Data in the system Your business data should remain yours Export rights and obligations under the Privacy Act 2020

None of this is a red flag in itself. Reusing proven components is efficient and keeps costs down. The key is knowing which parts you own outright, which parts you licence and on what terms.

Common ownership models in software contracts

Full assignment to the client

All IP in the bespoke work is assigned to you, usually on payment. The developer retains its pre-existing tools and grants you a licence to use them as part of the software. This is the most common model for genuinely custom business systems.

Developer ownership with a licence

The developer keeps the IP and grants you a licence to use the software. This is typical for products and platforms that are configured for many customers. It can be perfectly reasonable, as long as the licence terms are clear and fair, but it is closer to buying a product than commissioning bespoke work. Our article on custom software vs off-the-shelf explores that difference.

Shared or split ownership

You own the business-specific parts, while the developer owns a reusable core. This needs careful drafting so both sides know exactly what they can do with each part.

What to include in your development contract

Whether you are commissioning a small internal tool or a major platform, make sure your agreement covers these points:

  1. IP assignment. A clear clause stating that IP in the bespoke deliverables transfers to you, and when (for example, on full payment).
  2. Background IP licence. A perpetual, royalty-free, transferable licence to any pre-existing developer code included in your software.
  3. Open-source disclosure. A list of significant open-source components and their licences.
  4. Repository access. Your code stored in a repository (such as GitHub, GitLab or Azure DevOps) that your organisation owns or can access at any time.
  5. Accounts and credentials. Hosting, domain, app store and third-party accounts registered in your business’s name.
  6. Documentation. Technical documentation and deployment instructions delivered alongside the code.
  7. Confidentiality. Protection for your business information and ideas.
  8. Exit and handover. What the developer will provide if the relationship ends, including reasonable handover assistance.
  9. Subcontractors. Confirmation that any subcontractors’ work is also assigned to you.

Being clear about scope from the start also helps. A well-written brief defines what is being built and what deliverables you should receive; see our guide on how to write a software requirements brief.

Practical steps to protect yourself

  • Read the IP clause before signing, not after a dispute arises.
  • Ask for read access to the code repository from day one of the project.
  • Keep admin access to your own cloud, domain and app store accounts.
  • Request a list of third-party services and their ongoing costs.
  • Make sure contractors and freelancers working on the project have signed agreements assigning their work.
  • For high-value or regulated systems, consider a source code escrow arrangement where the developer retains ownership.
  • Keep copies of signed contracts, statements of work and variations together.

A reputable software development company will be comfortable discussing all of these openly and will put the answers in writing.

Frequently asked questions

If I pay for custom software, do I automatically own the code?

Under the Copyright Act 1994 commissioning rule, the person who commissions and pays for a computer program is generally the first owner of copyright, but this can be overridden by contract. Always check what your agreement actually says.

Can a developer reuse my code for other clients?

If you own the bespoke code, they generally should not reuse it without your permission. They may still reuse their own pre-existing tools and general know-how. Your contract and confidentiality terms should make the boundaries clear.

What is source code escrow?

Escrow is an arrangement where the source code is deposited with an independent third party and released to you if certain events happen, such as the developer going out of business. It is most common when you licence software rather than own it.

Does open-source code affect my ownership?

You will not own the open-source components themselves, but you can use them under their licence terms. Some licences, such as the GPL, have conditions about sharing source code if you distribute the software, so it is worth knowing what is included.

What if my old developer will not hand over the code?

Start by reviewing your contract and payment history, then request the code and credentials in writing. If ownership is disputed, get legal advice. This situation is exactly why clear contracts and repository access matter from the start.

Who owns the data in my software?

Your business data should remain yours, and you are responsible for personal information under the Privacy Act 2020. Your contract should give you the right to export your data in a usable format at any time.

Build with clarity from day one

Knowing who owns the source code of your custom software is not a legal technicality. It underpins your ability to grow, change suppliers, attract investment and protect what makes your business different. Agree ownership, licences and access in writing before development starts, and you will avoid most of the problems that lead to disputes later. If you are planning a new software development project and want to talk through ownership and handover in plain language, book a free 60-minute consultation with our Auckland team, or get in touch with any questions.

Share Article:
About Author

Consectetur sollicitudin cubilia facilisis lobortis lacus a ac phasellus. Mus pulvinar enim suspendisse pharetra id commodo platea nunc aliquet.