Insights
How do you make sure you own your code and data with a software partner?
By Rare Agentics engineering teamLast updated First published 9 minute read
You own your code and data when they live in accounts registered to your business from the first commit: your repositories, your cloud accounts, your domains and your third-party services, with the partner invited in as a user. Back that with a contract that assigns the intellectual property to you, documentation good enough for another team to take over, and no per-seat licence standing between you and your own system.
What does owning your software actually mean?
Most founders assume that if they paid for the software, they own it. Under UK copyright law the default often runs the other way. Code written by your employees in the course of their job belongs to you, but code written by a freelancer or an agency belongs to them unless a written, signed assignment transfers it to you. Without one, you usually have only a licence to use it. Practically, it is often false, because ownership is not only a matter of who holds the rights. It is a matter of who holds the keys.
You own your software in a way that matters if you can do all of these without asking the people who built it:
- Read, copy and change the code.
- Deploy it, or let another team deploy it.
- Get at every byte of your data, in a usable format.
- Keep the system running if the relationship ends tomorrow.
- Turn off the builder's access in an afternoon.
If any of those depends on the goodwill of your supplier, you have a dependency, not an asset. The rest of this guide is about closing each gap, and the questions to ask before you sign rather than after you fall out.
Whose name should be on the repositories?
Yours. The code should live in a GitHub organisation (a group on GitLab, a workspace on Bitbucket) that your business created, pays for and administers. Your partner's engineers are invited in as members. You are the owner; they are guests.
The common alternative is that the agency keeps the code in its own organisation and promises to "transfer it at the end". That promise has three problems. The end may never come cleanly. Transfers get forgotten or delayed when an invoice is disputed. And until it happens, you cannot see the commit history, the open issues or how the work is actually going.
What to check:
- Ownership on day one. The organisation is created in your name before the first line of code is written.
- At least two owners on your side. If the only admin is one person who leaves, you have a different lock-in problem.
- The whole history. Not a zip of the final code, the full repository with every commit, branch and review.
- Everything that builds and deploys it. Pipelines, infrastructure definitions and scripts belong in your repositories too, not on someone's laptop.
Who should own the cloud accounts and the data?
The same rule, applied to everything that runs the software and stores the data. Your AWS account, your Supabase organisation, your Vercel team, your database. Registered to your business, billed to your card or invoice, with the partner given the access their role requires.
This matters more than the code. Code can be rewritten. Data held in an account you cannot get into is very hard to recover, and personal data held in someone else's account is a data protection question you probably do not want to answer. If a supplier stores or handles your customers' personal data, UK GDPR requires a written contract that makes them your processor and limits what they may do with it.
Points worth confirming:
- Billing. If the supplier pays the hosting bill and recharges you, they control the account. A missed payment between the two of you can take the system offline.
- Root access. The top-level login for each cloud account should belong to someone in your business, protected with multi-factor authentication, and not used for day-to-day work.
- Backups. Where backups are stored, who can restore them, and whether anyone has ever proven a restore works.
- AI providers. If the system uses a hosted model, the account and API key should be yours, and you should know what that provider keeps. An agency key buried in your product means your data passes through their contract, not yours.
What should the contract say about intellectual property?
This section is not legal advice. Take advice from a solicitor on any contract you sign. What follows is what to ask for and what to ask about.
An assignment of intellectual property to you. Many contracts give you a licence to use the software rather than ownership of it. A licence can be limited, revoked or tied to ongoing payments. Ask whether the contract assigns the rights in the work produced for you, and when that assignment takes effect (on creation, or only on final payment).
What is excluded, and on what terms. Suppliers often keep the rights to their own pre-existing tools, libraries and templates, which is reasonable. Ask what is covered by that carve-out, and make sure you get a permanent, transferable licence to whatever stays theirs but sits inside your product. Otherwise a sale of your company can stall on a component you do not own.
Open-source components. Almost all modern software uses open-source libraries. Ask for a list of what is used and under which licences, because some licences carry obligations that matter if you distribute the software or sell the company. Some, such as the AGPL, can apply even when the software is only offered over a network.
Code written with AI tools. UK copyright law has a special rule for computer-generated works with no human author, and how it applies to code written by AI tools is unsettled. The practical protection is contractual: the contract should assign whatever rights exist in the work, whoever or whatever wrote it, and the supplier should stand behind the work regardless of how it was produced. Your solicitor can advise on the wording.
What happens at the end. Exit clauses, notice periods, the cooperation the supplier owes you during a handover, and whether any of it costs extra.
Which smaller accounts and credentials do founders forget?
The repositories and cloud accounts get attention. The long tail of smaller accounts is where ownership quietly leaks away.
Domains. Your domain should be registered in your business's name, at a registrar account you control. A developer registering it "to save time" is one of the most common and most painful forms of lock-in, because whoever holds the domain controls your website and usually your email.
DNS. The same applies to wherever your DNS is managed. If you cannot change a DNS record yourself, you cannot move your site.
Third-party services. Email sending, payments, analytics, error tracking, maps, search, app store accounts. Each one should be an account in your name. Make a list during the build, not at the end.
Credentials and secrets. API keys and passwords should live in a password manager or secrets store your business controls, shared with the supplier, not in their own vault. When the relationship ends, you rotate them, and you can only rotate what you know exists.
Access that outlives the person. Every engineer who worked on the project should be removable in one sitting. Ask for a list of who has access to what, and keep it current.
What documentation and handover should you expect?
A handover is not a meeting at the end. It is something that should be true throughout: at any point, a competent team you have never met should be able to pick the system up.
What that takes:
- A plain-English overview. What the system does, the main parts and how they fit together.
- How to run it locally. Steps a new engineer can follow without asking anyone.
- How it is deployed. The release process, the environments and who can approve a release.
- The rules that must never break. The business rules the system enforces, ideally backed by automated tests.
- Tests. Automated tests are the most honest documentation there is, because they fail when they go out of date.
- Where everything lives. Every account, service and environment, and who owns each.
Ask a supplier to show you an example of a handover note from a past project (with the details removed) before you sign. If they cannot, you have learnt something.
The best handover is the one there is no need for. When the code has lived in your repositories and the data in your accounts from the first commit, there is nothing to hand back. After launch you choose between a Run and improve plan and a full handover, and either works only because the accounts were yours all along.
How does per-seat and platform lock-in creep in?
Not all lock-in comes from agencies. Some is built into the product you end up with.
Per-seat pricing on your own system. Some suppliers build on their own proprietary platform and charge you a monthly fee per user to run what they built for you. It looks cheap at five users and expensive at fifty, and you cannot leave without a rebuild. Ask whether there are any ongoing licence fees to the supplier, and whether the software runs without their platform.
A low-code platform under the hood. Building on a no-code or low-code tool can be the right choice for an early prototype. Just know that you own the configuration, not the engine, and moving off it usually means starting again.
An unusual stack. A system written in a language or framework few engineers know is a quieter form of lock-in, because only the original team can maintain it at a sensible price. Ask why a stack was chosen, and how easy it would be to hire for.
Hosting you cannot see. "We host it for you" is fine as a service, provided it is your account and you could take it elsewhere.
What should you check before you sign?
| Item | Who should own it | What to ask the supplier |
|---|---|---|
| Code repositories | Your business, as owner | Will the code live in our organisation from the first commit? |
| Cloud and hosting accounts | Your business, billed to you | Whose name and card are on each account? |
| Databases and backups | Your business | Where are backups kept, and has a restore been tested? |
| Domains and DNS | Your business, at your registrar | Who will register the domain, and in whose name? |
| Third-party services | Your business | Will every service account be created in our name? |
| AI provider accounts and keys | Your business | Whose API key will the product use, and what does the provider keep? |
| Credentials and secrets | Your business's password manager | Where will keys and passwords be stored, and can we rotate them? |
| Intellectual property | Your business, by assignment | Does the contract assign the rights to us, and when? |
| Documentation and tests | Your business, in the repository | Could another team take this over from what you leave us? |
| Licences and ongoing fees | None, ideally | Are there any per-seat or platform fees to you after launch? |
If you are weighing up who to build with in the first place, our comparison of agencies, freelancers and in-house teams covers the trade-offs, and our list of questions to ask a software development company helps you test each answer before you sign. If you have inherited a codebase and are not sure what state it is in, making an AI-built app safe before launch is a good place to start.
How Rare Agentics can help
Every bespoke software build we do starts in your accounts. Your code lives in your repositories and your data in your cloud accounts from the first commit. There is nothing to hand back, because it was never ours, and the system stays with you if we ever part. Our operating platforms are hosted in your cloud with no per-seat pricing. If you want to check an existing arrangement or start a new build on these terms, get in touch.