Software

Who Owns Your Custom Software? What US Copyright Law Means When You Hire a Developer

Paying for software doesn't automatically make you its owner. How US copyright treats contractors, and what to put in writing before work begins.

2026-10-31 · 5 min

Many business owners assume that paying for software means owning it. Under US copyright law, that assumption can be wrong. If an outside developer writes your code and your agreement doesn't deal with ownership, you may end up with far less than you expected. The fix is usually straightforward, but it has to be in writing. This article is general information based on the US Copyright Act, not legal advice. Talk to an attorney about your own contracts.

The starting rule

Section 201 of the Copyright Act says copyright belongs first to the author of a work. The Act treats a computer program as a set of statements or instructions used in a computer to bring about a certain result. So the first question is who the author of the code is. Payment isn't the deciding factor. Authorship is.

Employees and contractors differ

The law has an important exception called work made for hire. When a work qualifies, the employer or commissioning party is treated as the author and owns the rights, unless the parties agree otherwise in a signed writing.

Section 101 gives two ways for a work to qualify:

  • It's prepared by an employee within the scope of their employment.
  • It's specially ordered or commissioned for use in one of nine listed categories, and the parties expressly agree in a signed written instrument that it's a work made for hire.

So if your own employee writes code as part of their job, the company generally owns it. Independent contractors and agencies are a different matter. Hiring a contractor isn't employment just because you call it that, and paying a fee doesn't change their status.

Why a work for hire clause may not be enough

The nine commissioned categories are a contribution to a collective work, part of a motion picture or other audiovisual work, a translation, a supplementary work, a compilation, an instructional text, a test, answer material for a test, and an atlas. Software isn't named on that list.

That creates a trap. A contract that only says the code is a work made for hire may not achieve what you want, since a commissioned program might not fit any category. Whether particular software could fit is a question for your attorney. The usual protection is to include an assignment as well, so that ownership transfers even if the work for hire language fails.

Assignments must be written and signed

Section 204 says a transfer of copyright ownership isn't valid unless it's in writing and signed by the owner of the rights or their authorized agent. A handshake, an email promising the code is yours, or a paid invoice shouldn't be relied on as a transfer.

If an agency subcontracts work, ask how rights flow from each individual developer to the agency, and then to you. An agency can only assign what it holds. Without that chain, a gap could sit in the middle of your product.

One more nuance: for grants that aren't works made for hire, Section 203 lets authors terminate a grant in a window that begins 35 years after it's made. For most business software, that period is unlikely to matter in practice, but it shows the two routes aren't identical.

What to put in your contract

Copyright is only one part of practical control. A good agreement, prepared with an attorney, should also address these points:

  • Assignment of all rights in custom code on payment, with work for hire language where it applies.
  • Rights from subcontractors and individual developers.
  • Pre-existing code. Vendors commonly reuse their own libraries, so agree a license that lets you use, change and move that code.
  • Open source components, with a list and their license terms.
  • Delivery of source code, documentation and build instructions.
  • Handover help if the relationship ends.

Ownership on paper vs control in practice

You can own the copyright and still be stuck if someone else holds the keys. Check that your business controls these assets directly:

  • The source code repository, with your company as the owner.
  • Hosting and cloud accounts.
  • Domain names and DNS.
  • Apple Developer and Google Play accounts.
  • App signing keys and API keys.
  • Databases and backups.
  • Third-party service accounts, such as payments and email.

Access can be granted to your vendor without handing them ownership. When a project starts, the easiest route is to create these accounts in your company's name and invite the vendor in.

Questions to ask a vendor

  • Do I own the code when the project is paid for?
  • Is that stated in the contract?
  • Which parts are your existing code, and what license do I get?
  • Can another developer take over without your help?
  • When do I receive the source code: as you go, or only at the end?

A confident vendor will answer these easily. Get source code access during the project if you can, rather than a single delivery at the end. If a vendor is unwilling to put ownership in writing, treat that as useful information before you sign.

If you already have software

Review your existing agreements and repositories. If rights were never assigned, it's often simplest to get a signed assignment now, while the relationship is good. An ownership gap is far easier to solve before a dispute, an investment round or a sale makes it urgent.

Our team can help you plan a software project where code ownership and handover are clear from the start.

Talk to the team