Alex is Sprintlaw’s co-founder and principal lawyer. Alex previously worked at a top-tier firm as a lawyer specialising in technology and media contracts, and founded a digital agency which he sold in 2015.
If I'm paying an app developer, do I own the app?
The reassuring answer is that you can own the code and key assets you're paying for, but it usually doesn't happen automatically just because you paid an invoice. In Australia, your ownership position depends heavily on what your contract says.
This matters when you're building a startup, raising capital, selling your business, changing developers, or simply trying to launch without being held back. A clear software development agreement can make the difference between owning a valuable product and only having a limited right to use what someone else built.
Who Owns The App Source Code If I Pay A Developer?
Usually, the developer owns the copyright in the source code unless your contract clearly assigns it to your business.
Under the Copyright Act 1968, source code is generally protected as a literary work. The person or company that creates the code usually owns copyright in it, unless an exception applies or there's a written assignment. Paying for the work isn't the same thing as receiving ownership.
This can surprise startups because the commercial expectation often feels obvious: you briefed the developer, paid for the work and funded the product. But without a written IP assignment, you may only have an implied licence to use the app for the purpose everyone had in mind.
That implied licence can be hard to rely on later. For example, it may not clearly let you:
- move the app to a new development team
- modify and commercialise the source code however you like
- use the same code in a second product
- sell or license the software to another business
- give investors comfort that your company owns its core technology
There's a different rule for employees. If an employee creates copyright material in the course of their employment, their employer will often own that copyright. But many app projects are built by external developers, agencies or contractors, so you shouldn't assume the employment rule applies.
For your business, the practical goal is simple: make sure the contract says who owns what, when ownership transfers, and what must be handed over before final payment.
What Should A Mobile App Development Agreement Cover?
A mobile app development agreement should cover the scope of work, payment milestones, IP ownership, source code handover, testing, support and limits on third party materials.
Think of the agreement as the operating manual for the project. It doesn't just protect you if things go wrong. It also helps both sides stay aligned while the app is being designed, coded, tested and released, with app terms and conditions considered before launch.
For an app project, your agreement should usually cover:
- Scope: what the developer is building, including platforms, features, admin dashboards, integrations, website development elements and deliverables.
- Specifications: wireframes, user stories, technical requirements and design references.
- Milestones: when each stage is due and what must be delivered before payment is made.
- Acceptance testing: how you test the work, report defects and decide whether a milestone is accepted.
- IP ownership: who owns the new code, designs, documentation and other project materials.
- Pre-existing IP: any code libraries, frameworks, templates or tools the developer already owned before the project.
- Open source and third party tools: what can be used, what licences apply and what needs your approval.
- Handover: source code repositories, credentials, build instructions, documentation and deployment access.
- Confidentiality: protection for your business model, data, roadmap, customer lists and technical information.
- Support and maintenance: bug fixes, updates, response times and whether ongoing support costs extra.
Say Mia is building a booking app for allied health clinics. She pays $45,000 across three milestones. The app works in a demo, but the developer won't hand over the GitHub repository until she signs a new maintenance deal. If Mia's agreement only says the developer will deliver a working app, but doesn't require source code handover, she may have a commercial headache even though she paid the invoices.
A good contract avoids that kind of grey area by spelling out exactly what delivery means.
How Should IP Assignment And Moral Rights Clauses Work?
Your contract should include a written IP assignment that transfers ownership of the project IP to your business, plus moral rights consents from the people creating the work.
An IP assignment is the clause that moves ownership from the developer to you. For copyright, it should be in writing and signed. The clause should be broad enough to cover the materials you actually care about, but clear enough that everyone knows what is included.
For an app development project, the assignment should usually cover:
- source code and object code created for the project
- app architecture, workflows and technical documentation
- UI designs, icons, graphics and custom animations
- database structures and admin portal materials
- test scripts, build scripts and deployment materials
- updates, patches, enhancements and bug fixes created under the agreement
The timing also matters. Some contracts assign IP when the work is created. Others assign it once you have paid the relevant invoice. Either approach can work, but you need to understand the commercial risk.
If assignment only happens after full payment of the entire project, you may not own partially completed work if the project ends early. A more practical structure may assign each milestone's IP once you pay for that milestone, with clear handover obligations at the same time.
What About Moral Rights?
Moral rights are personal rights held by individual creators under the Copyright Act 1968. They include the right to be attributed, the right not to be falsely attributed and the right not to have work treated in a way that harms the creator's honour or reputation.
Moral rights can't be assigned like copyright. Instead, the creator can give written consent for certain acts that might otherwise infringe their moral rights. In app projects, this matters because you may need to modify, adapt, combine, white-label or remove attribution from parts of the work later.
If you're contracting with an agency, don't assume the agency can give all moral rights consents on behalf of its employees and freelancers. Your agreement should require the agency to obtain the necessary consents from the individuals who actually create the code and assets.
What Happens With Open Source Components And Third Party Tools?
You generally won't own open source components or third party tools, so your agreement needs to control how they're used and what licence conditions apply.
Most modern apps use open source software, SDKs, APIs, cloud services, maps, analytics tools, payment gateways, fonts or design libraries. That's normal. The issue isn't that these tools exist. The issue is whether their use creates restrictions you didn't expect.
Open source licences vary. Some are permissive, such as MIT or Apache style licences, and may be relatively easy to manage if you follow the conditions. Others, such as certain GPL or AGPL licences, can create obligations that affect how your software is distributed or shared.
Your agreement should require the developer to:
- tell you before using open source components in your app
- provide a list of open source and third party materials used
- confirm the licence terms for each component
- avoid components that would force disclosure of your proprietary source code, unless you approve them in writing
- comply with attribution, notice and licence obligations
- make sure third party tools are suitable for commercial use
Third party tools can also affect your exit options. If a core feature depends on the developer's own private framework, a paid plug-in under their account, or a no-code platform you don't control, you may be locked in even if you technically own the custom code.
Ask for a dependency register before launch. This can be a simple list showing each third party component, who owns it, the licence, where it's hosted, renewal costs and whether your business has admin access. It's especially useful before fundraising, due diligence or a handover to another developer.
How Do Milestones, Acceptance Testing And Handover Protect IP?
Milestones, acceptance testing and handover protect your IP by linking payment to real deliverables, not just progress updates.
App builds are rarely one neat delivery at the end. They usually move through design, prototype, backend build, front end build, testing, launch and post-launch fixes. Your contract should make each stage measurable.
A Worked Example
Olivia runs a fitness startup in Melbourne and agrees to pay $60,000 for an iOS and Android app. The agreement breaks the fee into four milestones of $15,000:
- Milestone 1: clickable prototype and finalised UI designs
- Milestone 2: backend API, user accounts and class booking logic
- Milestone 3: mobile app build with payment integration
- Milestone 4: app store submission, bug fixes and handover
For each milestone, the agreement says the developer must deliver the relevant source code, documentation and access details before Olivia has to approve the milestone. Olivia then has 10 business days to test the work and report defects. Critical defects must be fixed before the milestone is accepted.
This structure gives Olivia practical leverage. If milestone 2 is incomplete, she doesn't have to pay milestone 2 just because some work has been done. If she does approve and pay milestone 2, the IP in that milestone transfers to her business and the code is already in her repository.
Without those details, Olivia might end up paying most of the project fee while the developer still controls the code, build process and credentials.
What Should Handover Include?
Your handover list should be specific. Ask for:
- source code repositories and commit history
- admin access to hosting, app store, analytics and cloud accounts
- build and deployment instructions
- API documentation and database schema information
- design files in editable formats
- test results and known issue logs
- licence details for open source and third party components
- passwords or credentials through a secure handover process
It's much easier to ask for these items before final payment than after the relationship has cooled.
App Development Contract Checklist: What To Include
Your app development contract should be tailored to your project, but a clear clause outline can help you see what's missing before you sign.
Templates often miss the details that matter most in a real app build, especially around source code, third party tools and staged handover. A lawyer should tailor the document before you use it, but this outline is a useful starting point for your internal checklist.
- Parties And Project Details: write the correct legal names, ABNs or ACNs, and a plain description of the app.
- Scope Of Work: attach the specifications, platforms, features, integrations and deliverables.
- Project Timeline: set milestone dates, review periods and what happens if either side causes delay.
- Fees And Payment Milestones: link each payment to specific deliverables and acceptance.
- Acceptance Testing: explain how you test, how defects are classified and when work is accepted.
- IP Assignment: state that new project IP is assigned to your business and when that assignment happens.
- Developer Pre-Existing IP: identify any tools, frameworks or code the developer keeps owning, and the licence you receive to use them.
- Open Source And Third Party Materials: require approval, disclosure and licence compliance.
- Moral Rights Consents: require consents from individual creators so you can modify and commercialise the app.
- Confidentiality: protect your product roadmap, data, customer information and commercial plans.
- Privacy And Data Handling: cover access to personal information, security practices, your privacy policy and any Privacy Act 1988 obligations that apply to your business.
- Warranties: require the developer to confirm the work is original or properly licensed, and doesn't knowingly infringe someone else's rights.
- Handover: list the code, accounts, credentials, documentation and design files to be delivered.
- Support And Maintenance: separate included bug fixes from paid future improvements.
- Termination: explain what happens to paid work, unpaid work, confidential information and access if the project ends early.
Also think beyond copyright. Your app name, logo and brand may be protected through trade marks registered with IP Australia. Your company details, shareholders and governance sit separately under the Corporations Act 2001 and ASIC processes. The contract should fit neatly into those wider business foundations.
Key Takeaways
- Paying an app developer doesn't automatically mean you own the source code or app assets.
- Your contract should include a clear written IP assignment covering code, designs, documentation, updates and handover materials.
- Open source software and third party tools are normal, but you need visibility over the licences and any restrictions.
- Moral rights can't be assigned, so you need written consents from the people creating the work.
- Milestones and acceptance testing help make sure you pay for delivered work and receive the IP as the project progresses.
- A tailored Australian app developer contract can help protect your product, fundraising plans and future exit options.
If you'd like help with your app development agreement, IP assignment clauses, source code handover process or open source and third party tool terms, you can reach us at 1800 730 617 or team@sprintlaw.com.au for a free, no-obligations chat.
Protect the asset behind the name or work
What should you clear, own or register?
Searches, ownership chains, assignments, licences and registrations solve different risks. Start by identifying the asset and how the business uses it.








