It’s the question almost every serious buyer has and almost nobody asks out loud: after I pay for this software, is it actually mine?
It matters more than it sounds. If you don’t own your software, you can be held hostage by the developer who built it — locked out of your own system, unable to hire anyone else to change it, forced to keep paying whatever they ask. Getting this right at the start avoids a painful, expensive fight later. Here’s the plain-English version.
What “owning your software” actually means
Software ownership isn’t one thing. It’s a few different things, and a fair deal hands you all the ones that matter:
- The source code. The actual instructions the software is built from. If you own this, you can take it to any developer and have it changed. If you don’t, you’re locked to the one who built it.
- The data. Everything the system holds — your customers, orders, records. This should unquestionably be yours, always, and you should be able to export all of it whenever you want.
- The right to change it, host it, and use it however you like. Ownership of code is worth little if you’re contractually barred from modifying it or moving it to a different server.
- The accounts and infrastructure. The domain, the hosting, the third-party accounts the system runs on should be in your name, not your developer’s. This one is quietly the most common trap.
When people say “do I own the code,” this is the full picture they should mean. Owning a copy you’re not allowed to touch, on a server you don’t control, is not ownership.
What you usually won’t own — and shouldn’t expect to
Here’s the honest other side, because a fair deal cuts both ways. A developer who has been building software for years brings their own pre-existing tools, libraries, and reusable components to your project. They didn’t create those for you — they built them before you came along and use them across many clients.
You don’t own those, and you shouldn’t expect to. What you should get instead is a licence to keep using them as part of your software, forever, without extra cost. That’s normal and fair: you own the custom part built specifically for you, and you have a permanent right to use the general tools it’s built on. Watch out only for the reverse — a developer trying to claim the custom work as their reusable property. That part is yours.
The same goes for genuinely third-party pieces: the open-source frameworks, the paid services your software connects to. Nobody owns those outright; everyone uses them under their own licences. That’s how all software is built, and it’s fine.
The trap: paying in full and still not owning it
The most common way businesses get caught is subtle. The software gets built, you pay every invoice, and everything seems fine — until you want to make a change and the original developer is slow, expensive, or gone. You go to hire someone else, and discover you can’t: you never got the source code, the hosting account is in the developer’s name, and the domain is registered to them. You paid for the software, but you can’t actually control it.
This is rarely malicious. More often it’s just never written down. The contract talked about building the software but never said, in plain words, who owns the result and who holds the accounts. The silence is the problem.
The questions to ask before you sign
You don’t need a lawyer to protect yourself here — you need to ask four direct questions and get them answered in writing:
- “When I’ve paid in full, do I own the source code?” The answer should be a clear yes for the custom work built for you.
- “Will the hosting, domain, and any third-party accounts be in my name?” They should be. If they’re in the developer’s name, you’re dependent on them to keep running.
- “Can I hire another developer to change this later?” A confident builder says yes without flinching. Hesitation here is a warning.
- “Can I export all my data, whenever I want?” Always yes. Your data being trapped in a system you can’t get it out of is its own kind of lock-in.
Get those four answers in writing before any money moves, and the ownership trap simply can’t close on you. A developer who answers all four cleanly is one you can trust with the rest.
How we handle it
So there’s no ambiguity about where we stand: when you pay in full for a deliverable, you own the custom code written for you. Your data is yours, always, and exportable. The accounts your software runs on go in your name. You’re free to take the code to anyone else at any time — we’d rather earn the next phase by doing good work than by holding your system hostage.
The only thing we keep is our own pre-existing tools and libraries, which you get a permanent licence to use as part of your software. That’s the fair line, and we write it plainly into every agreement. You can read the specifics in our terms and conditions, and the wider approach in how to get custom software built without it becoming a money pit.
This is not legal advice, and for a significant build it’s always worth having your own lawyer read the ownership and licensing terms. But now you know what those terms should say — and what to insist on before you sign anything.