app-entwickeln-lassen.de LogoApp entwickeln lassen

Planning & Process

Source Code Ownership and Usage Rights in App Development

app-entwickeln-lassen.de editorial team 7 min read
Contents
  1. Why "owning the code" works differently than most people think
  2. Usage rights your contract should spell out
  3. Custom code, agency components and open source
  4. Freelancers and subcontractors: the gap people overlook
  5. Checklist: what a source code handover must include
  6. Red flags in an offer
  7. Conclusion
  8. Frequently Asked Questions

Source code ownership in app development comes down to one question with big consequences: can you keep developing, sell or hand over your app without the original agency? The answer does not depend on who paid the invoice, but on which usage rights the contract grants and what is actually handed over. This guide explains what to look for, with a focus on projects developed under German law.

Why "owning the code" works differently than most people think

Under German law, software is protected by copyright as a computer program. The copyright itself stays with the person who wrote the code and generally cannot be transferred. What can be transferred are usage rights (Nutzungsrechte): the rights to copy, modify, distribute and make the code publicly available.

When offers mention "source code ownership" or "100 % code ownership", in practice this means the client receives exclusive usage rights that are unlimited in time, territory and content, plus actual access to the complete source code. Only this combination makes you independent.

A common pitfall is the so-called purpose-of-transfer rule (Section 31(5) of the German Copyright Act): if the types of use are not explicitly listed in the contract, rights are, in case of doubt, only granted to the extent required by the contract's purpose. A vague clause like "the client may use the app" could mean you may operate the app but not freely rebuild or resell it. Other jurisdictions have different rules, and this article is not legal advice – for a specific contract, consult a lawyer specialising in IT law.

Usage rights your contract should spell out

A solid development agreement grants rights explicitly. Check whether it covers the following points:

  • Exclusivity: only you may use the code developed for you. With a non-exclusive right, the agency could sell the same code to a competitor.
  • Right to modify: you may change and extend the code and have third parties do so.
  • Transferability and sublicensing: essential for company sales, investor due diligence or when a subsidiary operates the app.
  • All types of use: app stores, web, internal distribution and future platforms.
  • Timing of the transfer: often upon full payment. Clarify what applies to partial payments or if the project is cancelled.
  • Scope of deliverables: not just app code, but also backend, infrastructure configuration, design files, tests and documentation.

Custom code, agency components and open source

Hardly any app consists of 100 % newly written code. It typically combines several layers with different rights attached:

ComponentTypical rights situationWhat to check
Code written specifically for youExclusive usage rights for you, if agreed in the contractAn explicit clause, not limited to "operation"
Reusable agency modules (e.g. a login toolkit)Often a non-exclusive, perpetual licenceCan you modify and pass on the module? Are there recurring fees?
Open-source librariesThe project's licence (e.g. MIT, Apache 2.0, GPL)Licence inventory, copyleft risks, required notices in the app
Commercial SDKs and servicesThe vendor's licence agreementAre contracts in your name? What are the notice periods?

Copyleft licences such as the GPL in particular can trigger disclosure obligations when you distribute an app. Ask for a list of all open-source components and their licences. For more detail, see our article on open-source licences and AI-generated code.

The special case of AI-generated code

Many teams now develop with AI assistance. Whether, and to what extent, purely machine-generated code is protected by copyright at all has not been conclusively settled. For you as a client, the important thing is that the contract covers this regardless: all deliverables – whether written by hand or with AI support – are yours for exclusive use, and the agency warrants that no known third-party rights are infringed. Read more in copyright in AI-generated code.

Freelancers and subcontractors: the gap people overlook

For employed developers, German law (Section 69b of the Copyright Act) assigns the economic rights in code written as part of their job to the employer. This does not automatically apply to freelancers. If your agency works with freelancers or subcontractors, it must secure their rights by contract – otherwise it cannot grant you complete rights either. Ask about this directly in the first meeting and have the chain of rights confirmed in the contract.

Checklist: what a source code handover must include

Rights on paper are of little use if you lack access. These items should be in your hands at project completion at the latest – ideally throughout the project:

  1. Repository access: the full Git history, ideally in an organisation you own (e.g. on GitHub, GitLab or your own server).
  2. App store accounts: Apple Developer account and Google Play Console registered to your company, with the agency only as an invited team member.
  3. Signing keys and certificates: especially the Android upload key and signing access. Without them, every update becomes complicated.
  4. Cloud and hosting accounts: servers, databases, domains and push services in your name.
  5. Build and deployment process: CI/CD configuration and instructions for how a new team builds and releases the app.
  6. Secrets inventory: a list of all API keys and third-party accounts, handed over securely – not by e-mail.
  7. Documentation: architecture overview, data model, API description, known weaknesses.
  8. Design source files: not just exports, but the editable files from the design tool.

If you ever switch providers, you will quickly find out whether these points were met. Our guide on handing an app project over to a new agency explains how to make that transition orderly.

Red flags in an offer

  • Source code is only released "on request" or for an extra fee.
  • The app is published under the agency's store account.
  • The app depends on a proprietary agency platform with no exit arrangement.
  • The contract only mentions "a right of use" without further detail.
  • Maintenance and rights are coupled ("rights apply as long as the maintenance contract runs").

Such setups are not automatically dubious, but they create dependency. Raise them openly – you will find suitable questions in 15 questions to ask an app agency in the first meeting. At jocapps, the full transfer of source code rights to the client is part of every fixed-price offer; if you would like your project assessed, use our free offer request.

Agentic coding workshop for your team? From €799 net – request a quote by e-mail

Conclusion

An app is only truly yours when two things come together: explicitly agreed, exclusive and transferable usage rights, and real access to code, accounts and keys. Clarify the chain of rights, open-source components and handover scope before signing – fixing it afterwards is much harder and more expensive.

Frequently Asked Questions

Do I automatically own the source code once I have paid for the app?

No. Payment alone does not transfer comprehensive rights; what matters is which usage rights the contract explicitly grants. Without a clear clause, you may only receive the rights needed for the contract's purpose.

Can the agency reuse my code for other clients?

Not if you hold exclusive usage rights to the custom-developed code. The agency can usually still use generic building blocks and know-how, which the contract should clearly distinguish.

What is source code escrow?

The source code is deposited with a neutral third party and released under defined conditions, such as the vendor's insolvency. With custom development and full code handover, escrow is rarely needed; for licensed standard software it can make sense.

Under whose name should the app be published in the stores?

Under your company's name. The agency should only have team-member access, so reviews, users and update capability stay with you if you change providers.

This article was written by the editorial team of app-entwickeln-lassen.de – the app and AI development service of jocapps GmbH, based in Freiburg, Germany, and building apps since 2014. The content is for general information and does not replace individual (legal) advice.

You might also like

Planning & ProcessApp Acceptance Testing and Quality Assurance: What Clients Should Check

App acceptance testing and quality assurance: acceptance criteria, bug severity levels, a test plan and a checklist – so you can sign off safely before go-live.

6 min read
Planning & ProcessApp Relaunch Planning: 6 Phases From Old App to New App

App relaunch planning: how to carry users, data and store ratings over to your new app – with a phase plan, migration checklist and common pitfalls.

6 min read
Planning & ProcessWhy App Projects Fail: The Most Common Reasons and How to Prevent Them

Why app projects fail: the most common reasons, from unclear goals to missing maintenance – with early warning signs and countermeasures for your project.

6 min read
Planning & ProcessProduct Discovery: Find Out What Your App Users Really Want

Product discovery for apps: methods to validate user problems, solution ideas and willingness to pay before you commit your budget to development.

6 min read
Planning & ProcessApp Prototyping: Why a Clickable Prototype Pays Off Before Development

A clickable prototype before app development: when it pays off, which prototype types exist and how to test it properly – so you avoid costly changes later.

6 min read
Planning & ProcessApp Roadmap After Launch: How to Plan Your Next Releases

App roadmap after launch: how to prioritise new features, maintenance and budget, set a release rhythm and turn user feedback into a clear, flexible plan.

6 min read