# Who owns the code your software vendor wrote?

> In the US, UK and Australia, code an outside vendor writes is not yours by default. A signed assignment settles the title. Your repository settles the rest.

- Author: Marlon Trettin
- Published: 2026-11-13 · Updated: 2026-11-13
- Language: en
- Canonical: https://yowpi.com/en/blog/who-owns-the-code-your-vendor-wrote

---

Unless a signed document says otherwise, your vendor usually owns the copyright in the custom system it wrote. US law rarely treats outside code as a "work made for hire". In the UK and Australia, the first owner of software is the author or the author's employer, not the client. Payment does not transfer the title; a signed assignment does.

## TL;DR

- US law makes the hiring party the owner only for employees, or for nine listed kinds of commissioned work with a signed agreement. A standalone business system fits none of the nine comfortably, so the default sits with the vendor.
- The UK and Australia work the same way at the core: employers own employee work, and an assignment of copyright has no effect unless it is in writing and signed by the assignor.
- In its January 2025 report, the US Copyright Office said purely AI-generated material is not protected by US copyright. If your vendor generates much of the code with little human shaping, part of what you think you are buying may not be protected at all.
- The title is a contract question. Being able to change, move or rebuild the system is an architecture question: whose account holds the repository, the cloud and the deploy pipeline.

## Why doesn't paying for the code make it yours?

Because copyright starts with the author, and the exceptions are narrow. Under [17 U.S.C. § 201(b)](https://www.law.cornell.edu/uscode/text/17/201), the employer or other person for whom a "work made for hire" was prepared is treated as its author. The definition in [§ 101](https://www.law.cornell.edu/uscode/text/17/101) covers two cases: work by an employee within the scope of employment, and work specially commissioned in one of nine categories, such as a contribution to a collective work, a translation, a compilation or an atlas, when both parties sign a written agreement calling it a work made for hire.

Custom business software is not on that list. The Copyright Office is blunt about the conditions in [Circular 30](https://www.copyright.gov/circs/circ30.pdf) (revised August 2024): the agreement must be written, signed by all parties, and must expressly say the work is made for hire. "If a work fails to satisfy any of these requirements, it is not a work made for hire." A vendor with its own business, its own tools and its own staff is very unlikely to count as your employee under the agency-law factors the Supreme Court applied in *Community for Creative Non-Violence v. Reid*, as the same circular summarizes them.

So a contract that only says "work for hire" may not do what the parties meant. What moves ownership is a transfer, and [§ 204(a)](https://www.law.cornell.edu/uscode/text/17/204) says a transfer is not valid unless it is in writing and signed by the owner of the rights or an authorized agent. A sensible contract does both: the work-for-hire label where it applies, and an assignment as the backup.

## Is it different in the UK or Australia?

The mechanics differ, the default does not. Section 11 of the UK [Copyright, Designs and Patents Act 1988](https://www.legislation.gov.uk/ukpga/1988/48/section/11) makes the author the first owner, with one exception that matters here: work made by an employee in the course of employment belongs to the employer, subject to any agreement to the contrary. There is no commissioned-work category at all. [Section 90(3)](https://www.legislation.gov.uk/ukpga/1988/48/section/90) adds that an assignment is not effective unless it is in writing signed by or on behalf of the assignor.

Australia's Copyright Act 1968 follows the same pattern. [Section 35(6)](https://www5.austlii.edu.au/au/legis/cth/consol_act/ca1968133/s35.html) gives the employer copyright in work made under a contract of service, and [section 196(3)](https://www5.austlii.edu.au/au/legis/cth/consol_act/ca1968133/s196.html) says an assignment has no effect unless it is in writing and signed by or on behalf of the assignor. In all three countries the fix for outside work is the same document: a written, signed assignment.

What you hold without one depends on the contract and on what a court later reads into it. That is a weak position from which to change vendors. This article is not legal advice; the contract itself needs a lawyer in your jurisdiction.

## What should the assignment actually cover?

Our reading, from the systems side: everything you would need to run the system without the vendor. That means the source code, the database schema and migrations, the infrastructure and deployment scripts, the configuration, and the documentation of the business rules. An assignment that names only "the application" leaves room to argue about the rest. It should also state that the vendor holds those rights to begin with: code written by a freelancer or subcontractor belongs to that person unless they assigned it to the vendor in writing, and the vendor cannot pass on a title it never received.

Two things usually stay outside the assignment, and a good contract says so openly. One is the vendor's pre-existing components, the libraries and frameworks it reuses across clients. Those come to you under a license, and the license should be perpetual and should survive the end of the relationship. The other is open-source code, which arrives under its own license terms no matter what your contract says. Neither is a problem if it is listed. Both are a problem if you discover them on the day you leave.

## What changes when much of the code was generated by AI?

The asset you are buying may be thinner than it looks. In its [January 2025 report on copyrightability](https://www.copyright.gov/ai/Copyright-and-Artificial-Intelligence-Part-2-Copyrightability-Report.pdf), the US Copyright Office concluded that copyright does not extend to purely AI-generated material, or to material where there is insufficient human control over the expressive elements, and that prompts alone do not provide that control. Human authors keep protection for what they contribute: their own expression, their creative selection and arrangement, and their creative modifications of the output. The Office says this is decided case by case, and it describes US law only; the UK and Australia have their own rules, which this article does not cover.

A federal appeals court has held the same line. In [*Thaler v. Perlmutter*](https://media.cadc.uscourts.gov/opinions/docs/2025/03/23-5233.pdf), decided on March 18, 2025, the D.C. Circuit held that the Copyright Act requires work to be authored in the first instance by a human being. The Supreme Court [declined to review the case](https://www.supremecourt.gov/docket/docketfiles/html/public/25-449.html) on March 2, 2026, so that ruling stands. An assignment can only transfer the rights that exist. Where a vendor generated large parts of the code with little human shaping, the copyright you are paying to receive may cover less of the system than you assume. Ask how the code was produced, and expect a straight answer.

That shifts weight from the title to the copy. If ownership of some code is uncertain for everyone, what protects you is having it, being able to change it, and being able to run it without asking.

## Why isn't the title enough on its own?

Because a signed assignment gives you the right to the code, not the code. Ownership and control are separate questions, and the second one is decided by architecture, not by the contract. This is not a technology problem. It is an architecture problem: where the system lives, and who holds the keys.

Four checks answer it. The repository sits in an account your company owns, with the vendor added as a member, not the other way around. The cloud accounts, domains and third-party subscriptions are registered to your company. The deploy pipeline is written down and reproducible, with secrets stored where you control them. And someone outside the vendor has built and deployed the system from your repository at least once. The same logic sits behind [what actually keeps you tied to a software vendor](/en/blog/can-you-actually-leave-your-software-vendor), and behind the risk of [a system that depends on one person](/en/blog/does-your-internal-system-depend-on-one-person): knowledge and access that live outside your control.

## What does this look like in practice?

Consider a hypothetical case, not a client. A wholesale distributor with a few dozen staff hires a development firm to build its order and pricing system. The contract says the client "owns the deliverables" and defines deliverables as "the application". The firm keeps the code in its own repository host, deploys to a cloud account opened under its own billing, and reuses an internal library for authentication and reporting.

Three years later the distributor wants a second vendor to extend the system. It has a working application and a contract clause, but no assignment covering the schema or the scripts, no license for the reused library, and no access to the repository or the cloud account without the first firm's cooperation. None of this is bad faith. It is the default, left unexamined. Fixing it at signature takes a clause and an account setting. Fixing it at exit takes a negotiation.

The contract format matters here too. A [fixed price or hourly agreement](/en/blog/fixed-price-or-hourly-how-to-choose-a-software-contract) decides who carries the uncertainty of the build; the assignment and the repository decide who carries the system after it.

## Frequently asked questions

**We trust our vendor. Isn't asking for an assignment a sign of distrust?**

It is housekeeping, the same as holding the deed to a building you paid to have built. Vendors change ownership, key people leave, and relationships end for ordinary reasons. A clear assignment and a repository in your account protect both sides from a dispute neither one wants.

**Will a full assignment make the project more expensive?**

It can, if the vendor has to give up components it reuses across clients. The usual answer is to split the two: assign what is built for you, license what already existed, and list both. That keeps the price of reusable work low without leaving the core of your system in someone else's name.

**We have no one technical to check any of this. How do we know it is in place?**

Ask for evidence, not reassurance: the repository's owner account, the cloud billing account, and a written build and deploy procedure. Then have a third party follow that procedure once, at handover. If the system comes up from your repository, the architecture is in place. If it does not, you found out at a cheap moment.

## The next step

If you cannot say today whose account holds your system's code, cloud and deploy pipeline, or what your contract actually assigns, the [Operational Architecture Diagnostic](/en/contact) is a 30-minute conversation to map where ownership and control sit, and where they do not. It covers the systems side; the contract review stays with your lawyer.
