Who owns the code? Source code, IP and handover explained
Who owns the code when you pay someone to build software?
Whoever the contract says owns it, which is why the contract should say, in plain words, that you do. Paying for the work does not by itself guarantee that you own the code, and what applies when a contract says nothing differs from country to country. Put ownership in writing, and keep the repository and the cloud accounts in your company's name from day one, so the practice matches the paper.
This article is general information, not legal advice. The law differs by country, and sometimes by the kind of contract. For anything that matters, have a lawyer where you are read the contract before you sign it.
Owning the code and having a licence are different things
If you own the code, you can change it, sell it, hire anyone to work on it and stop paying the people who wrote it. If you have a licence, someone else owns the code and has given you permission to use it, on terms they set. A licence can be perfectly fine; it is how you use almost every piece of off-the-shelf software. But the terms decide what you can do later.
When you are offered a licence rather than ownership, read it for the limits that hurt when you grow or part ways:
- Can you change the code yourself, or hire another company to change it?
- Is it exclusive to you, or can the vendor sell the same software to your competitors?
- Does it end if you stop paying a support fee, or if the vendor closes?
- Can you transfer it if you sell the business?
- Do you get the source code, or only the running software?
Custom software usually comes with a mix of both
Most custom software is partly new code written for you and partly existing material: the developer's own reusable tools, third-party libraries and open-source components. The new code can be assigned to you outright. The existing material usually cannot, because the developer or a third party owns it and uses it for other clients too. What you get for that part is a licence to use it as part of your product.
That is normal. What matters is that the contract names it: what is new and yours, what existed before and is licensed to you, and on what terms. Ideally that licence is permanent, carries no further fees and moves with the product if you sell it, so you can keep running and changing the software without the original developer.
Why the repository and cloud accounts should be in your name from day one
Ownership on paper is half of it. The other half is control: whose accounts the code, the servers and the data live in. If the repository sits in the developer's account and the app runs in their cloud, getting it back depends on their goodwill, even when the contract says it is yours.
The fix is simple. Create the accounts yourself, in your company's name and on your company's billing, and invite the developer in:
- The code repository, on GitHub, GitLab, Bitbucket or similar, with the developer added as a member, not the owner.
- The cloud account, on AWS, Azure, Google Cloud or a hosting provider, with your company as the account holder.
- The domain name and its DNS.
- The Apple and Google Play developer accounts, so the app is published under your company's name.
- Third-party services: payments, email, SMS, maps, error tracking, analytics and AI providers.
- A password manager or secrets vault for the project, owned by you.
How we handle it at VA Org
Our code lives in the client's repository and the client's cloud account from the first commit. We are contributors, not landlords. Setting it up that way at the start costs nothing extra, and it removes the hardest part of any handover before the work begins. It is also one of the first things worth asking any company you are considering; our list of questions to ask a software development company puts it next to the others.
What about open-source and third-party components?
Almost every modern application is built on open-source libraries, and that is a good thing: they are widely used, well tested and save a great deal of work. But each one comes with a licence, and the licences differ:
- Permissive licences, such as MIT, BSD and Apache 2.0, generally let you use the code in a commercial, closed-source product as long as you keep the copyright and licence notices.
- Copyleft licences, such as the GPL, can require you to release your own source code under the same licence when you distribute software that includes the component. The AGPL can apply that requirement to software people use over a network, not only software you distribute.
- Paid components, such as commercial libraries, fonts, icon sets, stock images and map or AI services, are licensed per project, per seat or per use. Check that each licence is in your company's name and covers how you will use it.
Ask for a list of components and their licences
Agree in the contract that nothing goes into the product under a licence you have not accepted, and ask for a list of the main components and their licences as part of the handover. Tools exist that read a project's dependencies and list their licences, so this is not a large job for the developer. If a component's licence matters to your business model, have someone qualified check it.
What does a clean software handover include?
A handover is clean when a new team, your own or another company, could pick the software up without calling the people who built it. It should include:
- The repository, with its full history, every branch that matters and nothing left only on a developer's laptop.
- Infrastructure access: owner or administrator rights on the cloud account, the domain and DNS, the build and deployment pipeline and the app store accounts.
- Credentials: every password, API key and certificate, in a vault you control, and changed after the handover so former team members' copies stop working.
- Data: access to the database, the backups and the steps to restore them.
- Documentation: how to run the project locally, how it is deployed, what each environment is for, its configuration, the main design decisions and the outside services it depends on.
- Known issues: open bugs, shortcuts taken on purpose and the work that was planned next.
- A walkthrough: a session, ideally recorded, where the developers show your team around the code, run a deployment and explain how to fix a common problem.
Handover or support: both endings are fine
When a client would rather run the software themselves, we hand over documentation and a walkthrough for their own team, with the code already in their repository. The other ending is a care plan, where we keep looking after it with monitoring, backups, security patches and a named engineer on call. If you are weighing the two, the software maintenance cost calculator shows what running it yourselves is likely to involve.
What to put in a software development contract about the code
You do not need a long contract, but these points belong in it. Use them as a checklist to go through with your lawyer, not as a replacement for one:
- Ownership: that the code, designs and documentation written for you belong to you, and from when, for example as they are created or once they are paid for.
- Pre-existing material: what the developer brings in, who owns it, and the licence you get to it, including that the licence continues after the contract ends.
- Open source: that components come with licences you have accepted, and that you receive a list of them.
- Where the work lives: your repository and your cloud accounts, from the start.
- Handover: what you receive at the end or on early termination, and how quickly: code, access, credentials, documentation and a walkthrough.
- Confidentiality: that your code, data and business details stay private.
- Fixes after launch: how long the developer fixes defects at no extra cost, and what counts as a defect rather than a change.
- Ending early: notice periods, payment for work done, and the handover of work in progress.
Our own answers to those points
You own the code from the first commit, and it lives in your accounts. Fixed-scope builds include 30 days of fixes after launch, and a dedicated team runs month to month with 30 days' notice either way; our comparison of fixed price, time and materials and dedicated teams explains when each fits. See how we run custom software development.
What if another team already has your code?
If you are mid-project and the code is not in your accounts, ask for it to be moved now, while relations are good, not at the end. If the original team has gone, start with an audit before deciding anything: what exists, which account it is in, which credentials you still control, and whether someone new can build and deploy it. We start any takeover with a short paid audit for the same reason: what is salvageable, what isn't, and the cost either way, before anybody commits to a rebuild.
Do I own the code if I paid for it?
Not necessarily. Whether paying for the work also transfers ownership depends on your contract and on the law that applies to it, which differs between countries. The safe course is a contract that says it plainly, and a repository in your name so the practice matches the paper.
Should the source code be in my own GitHub account?
Yes, or in whichever code host your company uses, in an account your company owns. Invite the developers as members with the access they need, and remove them when the work ends. It costs nothing at the start and makes any later change of team far easier.
What is source code escrow?
It is an arrangement where a vendor deposits its source code with a third party, who releases it to you if agreed events happen, such as the vendor closing or ending support. It is mostly used when you license software rather than own it. For software built for you, keeping the code in your own repository usually does the same job more simply.
Can a developer reuse code they wrote for my project?
It depends on the contract. Developers commonly keep their general know-how and their own pre-existing tools, while code written specifically for a client's product is often assigned to the client. If reuse matters to you, say so in the contract, together with confidentiality for your data and business rules.
What can I do if a developer won't hand over the code?
Start with what you already control: the domain, the cloud account, the app store accounts and any copy of the code you hold. Ask for the handover in writing, pointing to your contract, and take legal advice in your country before escalating. If you get the code back but have nobody to run it, tell us what you have: we start every takeover with a short paid audit of what it would take to carry on.