Here's the fact that surprises most business owners: in Australia, when you pay a contractor or agency to write software, the developer owns the copyright by default — not you. Unlike employees (whose work belongs to the employer), a contractor keeps ownership of what they create unless the contract explicitly assigns it to you. Paying the invoice does not transfer the IP. This isn't an obscure technicality; it's the standard position under Australian copyright law, and plenty of providers rely on you not knowing it.
How the hostage trap works
A provider who owns your code — or simply controls the only copy of it — holds your business still while they negotiate. The trap usually has these parts:
- "IP transfers on final payment" — with "final" conveniently undefined while support invoices keep arriving.
- A licence instead of ownership — you may use the system, but you can't take it to another developer, and the licence dies when the relationship does.
- The repository you've never seen — the code lives only in the provider's accounts. Whatever the contract says, possession is leverage.
- Accounts in their name — hosting, domains and app-store listings registered to the agency, so even leaving with the code means rebuilding the plumbing.
None of this is illegal. All of it is why "we've been unhappy for two years but can't leave" is one of the most common sentences we hear.
What to check in your contract
- Is there an assignment of IP clause — the word "assigns", not "licenses" — and when does it take effect?
- Where does the code live day to day, and do you have administrator access to that repository right now?
- Whose name is on the hosting, domains and developer accounts?
- Is there an exit clause obliging documentation handover, and does anything about leaving trigger a fee?
- Are third-party components (licences, libraries) documented, so what's assigned to you is actually usable?
What genuine ownership looks like
The test is simple: ownership that only exists in the contract is a promise; ownership you can see is a fact. In a healthy arrangement, every commit lands in your corporate repository — your GitHub or Bitbucket organisation, your admin rights — from the first day of the engagement, not at handover. Infrastructure runs under your accounts. Documentation lives with the code. If the relationship ended tomorrow, another competent team could pick it up without asking your old provider for anything.
That's how we structure every engagement, and not out of charity: a provider who can't hold your IP hostage has to keep earning the work on delivery speed and quality. That's a healthier deal for both sides — and any provider who resists visible, day-one ownership is answering your question for you.