Skip to content
Two men in a café go through a contract on a clipboard; one signs while the other watches, with coffee and a laptop on the table.

Photo: Vitaly Gariev / Unsplash

Vetting

App development contract: 12 clauses to check before you sign

An app development contract must say who owns the code and when, whose name the store accounts are in and how changes are priced. 12 clauses to check.

By Syed Taha Rizvi, founderPublished 8 min read

On this page

Key takeaways

  • In the US, copyright starts with the author, which for an agency's staff means the agency, and a transfer is only valid in writing signed by the owner (17 U.S.C. §204(a)).
  • Custom app code isn't one of the nine commissioned "work made for hire" categories in US law, so ask for a signed assignment of copyright as well.
  • In the UK, an employer is the first owner of code its employees write, but an assignment from an outside developer only takes effect in writing signed by them.
  • Apple's app transfer moves the store listing, not the source: Apple says the current owner must exchange "the actual code set" directly with the recipient.
  • Have the Apple and Google developer accounts and the code repository opened in your name before work starts; it's simpler than any transfer clause.

An app development contract should answer six questions: what's being built (every screen), what you pay and when, how changes are priced, how you sign off the work, who owns the code and from when, and whose name the App Store and Google Play accounts are in. If any answer is vague, fix it before you sign.

Our own contracts answer all six, so here's my bias up front: the clauses I'd read twice are 5 and 6. In the US, the UK and Australia, paying for code doesn't make it yours. The contract has to hand it over to you.

I'm not a lawyer, so every law and store rule below is linked to the official page, checked on 11 November 2026. You don't have to take my word for any of it.

The 12 contract clauses grouped by question: what you get and pay for (scope, payments, changes, acceptance), what you own (code, store accounts, source, licenses), what protects you.
Clauses 5 to 8 decide whether the app is really yours; they are the ones most often left vague.

1. Scope: the screen list and the exclusions

Every other clause points back to the scope. A fixed price, a change request and an acceptance test only mean something if it's written down. It should list every screen, including standard ones such as sign-up and settings, the core flow, what the admin dashboard does, and what's excluded (content writing, store fees, hosting). Our app requirements document template shows what to put in one.

Red flag: "a fully featured app" with no screen list. That describes a hope, not an app.

2. Milestones and payment stages

Each payment after the first should be tied to something you can check yourself: the core flow on your own phone, every agreed screen working, a store submission from your account. Payments by calendar date, or half the price up front, put the risk on you. Holding back a final share until after launch keeps launch fixes quick.

Our own stages are set this way, so I'm not neutral here.

3. Change requests

Scope always moves. The contract should say how: you ask, the developer prices the change in writing, and no work starts until you approve. Check which rate or price list applies, and how many feedback rounds each milestone includes. Without this clause, a fixed price drifts like an hourly one; see fixed price vs hourly app development.

Across a desk by an office window, a woman in a grey suit holds out a page and a pen to a man seen from behind.
A change request should come back as a written price for you to approve and sign before anyone starts the work. Photo: Vitaly Gariev / Unsplash

4. Acceptance testing

This clause says how a milestone is signed off: how many working days you have to test, what counts as a pass (the app does what the scope says), and how bugs get fixed. Test a build you install, not a screen-share. Apple's TestFlight and Google Play's internal testing let any developer send you one.

Red flag: "deemed accepted" after a short window.

5. Who owns the code an app developer writes?

Unless your contract says otherwise, usually the developer. In the US, UK and Australia, paying for the work doesn't by itself make you the owner of the code. The contract has to move it to you.

Default code ownership: US, the author, moved by a signed written transfer; UK, the author, moved by a signed written assignment; Australia, the contractor unless the contract says otherwise.
The default rules in three countries, with the sections they come from; the official wording is quoted below.

United States

US law starts with the author. Title 17, chapter 2, §201(a): "Copyright in a work protected under this title vests initially in the author or authors of the work." And §204(a): "A transfer of copyright ownership, other than by operation of law, is not valid unless an instrument of conveyance, or a note or memorandum of the transfer, is in writing and signed by the owner of the rights conveyed or such owner's duly authorized agent."

So the code starts out as the developer's, and only a signed document moves it to you. A paid invoice doesn't.

Many contracts reach for "work made for hire" instead. The U.S. Copyright Office's Circular 30, Works Made for Hire (revised 08/2024) sets four tests for a commissioned work, the first being one of nine categories, and says: "If a work fails to satisfy any of these requirements, it is not a work made for hire."

The nine are publishing and film categories, such as translations, compilations, tests and atlases. Custom app code isn't one of them, and code written by an agency's own staff belongs to the agency as their employer. So a "work made for hire" line may not make you the owner. I'd ask for a written assignment of copyright as well, signed by the developer, before anything else.

United Kingdom

The Copyright, Designs and Patents Act 1988 counts "a computer program" as a literary work (section 3(1)), and section 11(1) gives it to the author first: "The author of a work is the first owner of any copyright in it, subject to the following provisions." The main exception is section 11(2): "Where a literary, dramatic, musical or artistic work, or a film, is made by an employee in the course of his employment, his employer is the first owner of any copyright in the work subject to any agreement to the contrary."

That exception is narrower than it looks.

The employer rule covers employees only. An agency or freelancer you commission isn't your employee, so you need an assignment, and section 90(3) sets its form: "An assignment of copyright is not effective unless it is in writing signed by or on behalf of the assignor."

Australia

The law is the Copyright Act 1968. The Australian Government's Creative Workplaces site, run by Creative Australia, states the default: "Intellectual property created by an independent contractor is owned by the contractor unless it is otherwise agreed in the contract." Employees are the other way round: what they create in the course of their employment "is owned by the employer unless it is otherwise agreed in the employment contract."

Three countries, one answer: if the contract is silent, the code stays with the developer.

What the ownership clause should say

  • The code, designs and other work for your app pass to you, with the trigger stated: as each milestone is paid, or on final payment.
  • It's an assignment of copyright signed by the developer, not just a license.
  • The developer's own pre-existing tools are licensed to you permanently, so you can keep changing the app without them.
  • Any subcontractor has assigned their work to the developer, so it can pass on to you.

6. Who owns the App Store and Google Play accounts

The code is half of owning an app. The other half is the store listing, with its users and ratings, which lives in a developer account.

Apple's enrollment page tells the person enrolling an organization: "you'll be the Account Holder and must have the legal authority to bind your organization to legal agreements." It adds: "Your organization's name will be displayed as the seller name of your apps on the App Store."

That second line is the one to notice. Whoever enrolled is the seller your users see. Membership is "99 USD per membership year", and Google's Play Console help says: "There is a US$25 one-time registration fee."

If the app sits in the developer's account instead, getting it back depends on them. Here are the official rules for moving it:

MovingWhat the official page says
An app between Apple accounts"Your membership Account Holder initiates the app transfer." "The receiving Account Holder accepts the app transfer." (Apple: overview of app transfer)
The code, on Apple"The transferor is responsible for exchanging the actual code set and building assets directly with the recipient." (same page)
An unreleased app, on Apple"The app must have at least one version that was released to the App Store." (Apple: app transfer criteria)
An app between Google Play accounts"The target developer account owner receives the request to review and approve." "After approval, support reviews and responds to transfer requests within two business days." (Play Console help: transfer apps)
A whole Google Play accountAn April 15, 2026 policy announcement requires "the official 'Transfer ownership' workflow within the Play Console". "Individual developers who monetize their apps are currently ineligible for this direct transfer process," and "The transfer will be placed on hold for 7 days." (Play Console help)

Every row needs the other side to act, which is why I'd rather the app never sat in their account at all.

The clause you want: every store, database, domain and payment account is opened in your name before work starts, with the developer invited. If any account is already in the developer's name, they must start the transfer within a set number of days of your request.

7. Source-code access

The repository should sit in your own GitHub (or similar) organization from the first commit, with the developer invited, so you keep the full history. A compiled app in the store can't be turned back into workable code, so without the repository you can't change the app. The clause should also cover the backend, database access, the Android signing key and every API key.

Red flag: code handed over "at the end". The end is when you have the least leverage left.

8. Third-party and open-source licenses

Every app is built on other people's code: open-source libraries, SDKs, and paid services such as maps or payments. Each has a license, and many have conditions. The MIT License, for example, requires that "The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software" (Open Source Initiative).

Ask for a list of every third-party component and its license, a promise that nothing is included you aren't allowed to use, and paid services in your accounts, not on the developer's keys.

9. Confidentiality and NDA

An NDA should run both ways and cover your idea, your business information and your users' data. Check two details: whether the developer may show your app in its portfolio, and how long the duty lasts after the project ends.

10. Warranty and bug-fix period

Look for a set period after launch when bugs are fixed free, a definition of a bug (the app doesn't do what the scope says), and a response time for critical problems such as payments or sign-in failing. If Apple or Google reject the app because of the developer's code, that fix should be free too.

11. Termination: how you leave with everything

You should be able to stop at a milestone, pay for the work done so far, and keep everything built. Watch for a kill fee for the full price, or code released only on final payment. The handover should be listed: a README, release steps, an account list, keys and passwords. If a developer has already gone quiet, see what to do when a developer abandons your app.

12. Data protection

If the developer can see your users' personal data, in the database, crash reports or test data, the law may require specific terms. In the UK, the ICO's guidance on contracts says: "Whenever a controller uses a processor, there must be a written contract (or other legal act) in place." One required term: "The processor must delete or return all personal data to the controller (at the controller's choice) at the end of the contract, and the processor must also delete existing personal data unless the law requires its storage."

Put simply: when the project ends, your users' data comes back to you or is deleted, and you choose which. Other countries have their own rules, so ask which ones the developer works to.

The contract checklist

  • Scope: every screen, the core flow, the admin and the exclusions
  • Payments: each stage after the first tied to something you can check
  • Changes: priced in writing and approved before work starts
  • Acceptance: days to test each milestone, and what counts as a pass
  • Code: a signed assignment to you, with the trigger stated
  • Store accounts: Apple and Google in your name before work starts
  • Source: your GitHub from the first commit, with backend and keys
  • Licenses: every third-party component listed; paid services in your accounts
  • NDA: two-way, with portfolio use agreed
  • Warranty: a free bug-fix period with a critical response time
  • Exit: stop at a milestone, keep everything, get a handover
  • Data: processor terms where needed; data deleted or returned at the end

For the checks that come before the contract, read how to choose an app development company.

If you do one thing this week, I'd make it this: open the Apple and Google developer accounts in your own name. It's $99 a year and $25 once, and it settles clause 6 before anyone drafts a word of the contract.

How our contracts answer these

Ours put these answers in writing. Your App Store, Google Play, database, domain and payment accounts are opened in your name, the code is in your GitHub from the first commit, and ownership of the code passes as each milestone is paid. You can stop at any milestone, keep everything built so far and get a proper handover. See what every mobile app development build includes.

Questions people ask

Who owns the code an app developer writes?

Unless the contract says otherwise, usually the developer, not the client. In the US, copyright starts with the author and a transfer is only valid in a signed writing. In the UK, only employers get first ownership automatically, and an assignment must be in writing signed by the developer. Australian government guidance says a contractor owns what they create unless the contract says otherwise.

Is a "work made for hire" clause enough to own my app's code in the US?

Not reliably. For an outside developer, US law treats commissioned work as made for hire only in nine listed categories, such as translations and atlases, and app code isn't named among them. Ask for an assignment of copyright as well, signed by the developer, so ownership passes to you even if the work-for-hire label fails.

Should my app be published under my developer account or the agency's?

Yours. Apple shows the organization's name as the seller on the App Store. Moving an app later needs the current owner's help: on Apple the current Account Holder starts the transfer, and on Google Play the target account approves a request from the original one. Opening both accounts in your name before the build avoids that.

What should an app development contract say about ending early?

That you can stop at a milestone, pay for the work done to that point and keep everything built so far, with a written handover: code, designs, keys, account access and release steps. Watch for a kill fee for the full price, or code that is only released on final payment.

Do I need a lawyer to review an app development contract?

For the ownership, liability and termination clauses, a short review by a lawyer in your country is worth paying for. A checklist like this one helps you spot what's missing first, so the lawyer's time goes on the wording that matters rather than on clauses that were never there.