Your app is working, the invoices have been paid, and you have a link to its source code. Does that mean your business can appoint another developer, publish an update or move the backend?
The answer depends on several separate things: the rights your business holds, the accounts it controls and the material another team needs to continue the work.
Source code ownership concerns legal rights in the code. A repository stores project files and their recorded development history. A hosting account controls services used to store code or run parts of the application.
These can belong to different parties. Understanding the distinction helps you ask clearer questions before commissioning an MVP, reviewing an existing app or changing developers.
Think of Plans, a Workshop and Permission to Use the Design
Imagine commissioning a product that will be manufactured in a rented workshop.
You need access to its design files. Someone needs to control the workshop and its equipment. You also need the appropriate rights to manufacture, modify or commission further work on the design.
Receiving a folder of drawings does not give you the workshop keys. Having the keys does not establish which rights you hold in the design.
An app has similar distinctions. Its source files, operational accounts and legal rights need to be understood separately.
What Is a Repository?
A repository is where a project's version-controlled files and history are maintained. With Git, it can exist locally on a developer's computer and be shared through a remote service such as GitHub or GitLab.
For a mobile app, repository content might include:
- Flutter and Dart source files.
- Android and iOS project configuration.
- Automated tests.
- Dependency declarations and lockfiles.
- Build scripts and development instructions.
Backend code might be in the same repository or another one. The database, uploaded customer files and live service settings may be stored elsewhere.
Repository access has different levels
Being able to view a repository is different from being able to change it or administer its settings.
For example, GitHub organisation repositories support roles such as Read, Write, Maintain and Admin. A person who can contribute code may still lack permission to manage access or transfer the repository.
Check the actual role granted to the business. A working link or an invitation labelled “collaborator” does not explain every permission.
Platform ownership is an administrative label
A hosting platform may describe an account or organisation as the repository's owner. That identifies where the repository sits and who administers it on that platform.
It does not, by itself, establish copyright ownership of every file inside it.
What Does “Hosting Account” Mean?
The word hosting can refer to two different services in a software project.
Code hosting stores the development project
A code-hosting platform stores remote repositories and may provide tools for reviews, issue tracking and automated workflows.
This is where developers share and discuss recorded changes.
Application hosting runs the software's online services
An application-hosting or cloud account provides resources used by the live product. Depending on the architecture, these might include servers, APIs, databases, file storage and background jobs.
Examples include a backend hosted on OVHcloud, AWS or Google Cloud, or managed services accessed through Firebase or Supabase.
A mobile app runs partly on the customer's device, but it can still depend on these online services for sign-in, bookings, subscriptions or stored information.
Billing access and technical access can differ
Receiving an invoice does not necessarily mean you can change server settings. Being able to deploy an update does not necessarily mean you can manage billing or recover the account.
Record who handles billing, administration, daily operations and account recovery. One person or company may perform several roles, but the responsibilities should remain clear.
What Is Source Code Ownership?
Source code ownership concerns the legal rights associated with the code, rather than the location of its files.
Depending on the arrangement, a business may receive an assignment of specified rights, a licence to use the software, or different rights for different components.
An assignment transfers specified rights where the applicable legal system permits it. A licence grants permission to carry out defined activities while ownership can remain with the rights holder.
The practical questions include whether your business can operate the software, modify it, appoint another maintainer and distribute the resulting application.
The answers depend on the agreement and applicable law. Employment and commissioned development can also be treated differently. The World Intellectual Property Organization's copyright explanations provide general background; project-specific terms should be reviewed by a qualified legal professional.
Payment and file delivery are not a complete rights statement
An invoice confirms a commercial transaction. A source archive provides files. Neither should be treated as a complete explanation of which intellectual property rights were granted.
If a contract says rights transfer after payment, clarify which deliverables and rights that provision covers. Avoid assuming that the same wording or legal effect applies to every development arrangement.
Why an App Can Contain Several Categories of Code
“We own the app” can hide important distinctions between its components.
Code created specifically for the project
This could include a custom booking workflow or an application-specific integration. The agreement should explain the rights granted in these deliverables.
Pre-existing developer components
A developer may use a library or tool created before the engagement. The business needs to understand whether it receives rights sufficient to keep using and maintaining the delivered application.
Open-source and commercial dependencies
Frameworks, packages, fonts and other third-party components have their own licence terms. Including them in an app does not automatically transfer their copyright to the client.
The important task is to identify relevant dependencies, their conditions and any subscriptions or permissions needed for continued use.
Likewise, making a repository public does not automatically grant unrestricted reuse rights. GitHub distinguishes repository visibility from the licence governing its contents.
One Booking App Example
Consider a fictional workshop-booking app with this arrangement:
- The Flutter source code is stored in the developer's GitHub organisation.
- The client can read the repository but cannot manage its access.
- The backend runs in a cloud account administered by the developer.
- The client pays a monthly service invoice.
- The mobile app is published through a separate developer account.
This arrangement does not, on its own, tell us whether the client owns copyright in the custom code. That requires examining the relevant rights and agreements.
It also does not tell us whether another developer can continue the work. They might be able to download the source but lack access to the backend, build configuration or store submission process.
There are three separate questions: what can the business access, what can it operate, and what is it legally permitted to do?
Should Every Account Be Under the Client's Control?
For a custom app intended to remain with the business, a useful starting model is to place critical project resources under business-controlled organisations or accounts and delegate appropriate access to the development team.
The business can retain continuity while the developer handles daily technical work. Control does not require a nontechnical founder to administer servers personally.
Use named users and suitable roles where the platform supports them. Document recovery arrangements so continued access does not depend entirely on one person's private email address.
Managed services need a clear exit model
A provider may legitimately operate a managed service on its own infrastructure. A subscription product may also give customers access to a service without delivering the underlying platform's source code.
In these models, clarify what the business receives: data exports, configuration, integration code, migration assistance or continued service under an agreed licence.
The goal is an explicit operating model with understandable options when the relationship changes.
Which Assets Need to Be Mapped for a Mobile App?
A repository is one item in a wider system. An asset register helps show which other accounts and resources the product depends on.
Source and development resources
Identify mobile and backend repositories, private packages, build workflows and editable design files where they form part of the agreed deliverables.
Include an architecture summary explaining how the application's parts connect. Clear code responsibilities and interfaces also make the project easier for a new developer to understand.
Infrastructure and data
Record the API hosting, database, file storage and backup locations. Identify who can administer them and who is responsible for maintenance and recovery.
A database structure recorded in Git is different from the live records customers create. Both may be needed for continuity, through appropriately authorised access.
Domains and DNS
The domain registration and DNS settings determine how addresses reach the application's services. These may be managed separately from hosting.
A working website address does not establish that the business can renew the domain or change its DNS configuration.
App distribution and signing
Identify the App Store Connect and Google Play Console arrangements, along with the signing and release processes needed for updates.
Signing arrangements differ between platforms. Document the process and responsible accounts rather than assuming every signing key can or should be downloaded and handed over.
Subscriptions and supporting services
An app may also depend on subscription management, paywalls, advertising, analytics and monitoring. Examples can include RevenueCat, Superwall, AdMob or PostHog.
List the services actually used by the project. For each, record the relevant account, project, permissions, billing responsibility and transition requirements.
Why a Repository Transfer Is Only One Part of Handover
Transferring a repository changes its administrative location on the code-hosting platform. It does not automatically move the application database, domain or cloud infrastructure.
On GitHub, repository transfers can preserve associated items such as issues and pull requests. Existing collaborators, secrets and deploy keys may also remain, so access and integrations need to be reviewed after transfer.
Other services have their own procedures. Supabase, for example, documents requirements for transferring a project between organisations.
Mobile store transfers require separate preparation
Apple and Google provide app-transfer processes with eligibility requirements and integration considerations.
Google Play specifically notes that permissions and links for integrated services do not transfer automatically. Firebase, analytics and advertising integrations may need separate changes.
For an actual transition, follow the current Apple app-transfer guidance and Google Play transfer guidance for the app's configuration.
Keeping a mobile listing available, preserving customer access and preparing future releases should be planned together.
What Does a Verifiable Technical Handover Look Like?
A handover becomes easier to assess when it includes observable outcomes rather than a single promise to “deliver the code.”
- Confirm authorised access. The incoming team verifies that the intended repository and service permissions work.
- Identify the current release. Record the source revision, backend environment and build associated with the running product.
- Build from a clean setup. Follow the documentation on another development environment using authorised dependencies and configuration.
- Exercise a test deployment. Verify the agreed release process in a suitable non-production environment.
- Check essential integrations. Test relevant flows such as sign-in, bookings and subscription access.
- Verify data recovery. Restore an agreed backup into an isolated environment and record the result.
- Confirm operational responsibility. Identify who handles incidents, renewals and releases during the transition.
- Review outgoing access. Remove or adjust accounts, keys and tokens that are no longer required once the replacement arrangements are verified.
A successful test build demonstrates technical readiness for that build. It does not establish copyright ownership. Rights documents and operational verification answer different questions.
What Should Be Clarified Before Development Starts?
Turn broad promises into questions the developer, business and relevant advisers can answer:
- Which custom deliverables will be supplied?
- Which rights are assigned or licensed, and under what conditions?
- Can another authorised team maintain and extend the application?
- Which pre-existing and third-party components are included?
- Where will repositories and production services be administered?
- Who pays recurring charges and handles renewals?
- What documentation, data exports and transition assistance are included?
- How will handover completion be checked?
The technical scope should match the commercial and legal arrangements. For example, a promise that another team can maintain the app needs to account for any private package or service required to build it.
What If the Developer Already Controls Everything?
Start by documenting the current arrangement. Locate the relevant agreements and list the repositories, accounts, resources and access levels that exist today.
Then agree which resources should be transferred, which can remain managed services and which need replacement arrangements.
Move through a planned transition rather than cancelling accounts or revoking access before checking the dependencies. A deployment workflow may still rely on an outgoing account or credential.
Keep a record of what was transferred, what was tested and what remains outstanding.
Frequently Asked Questions
If I pay for the hosting, do I own the code?
Hosting payments concern a service. They do not by themselves define the rights granted in the application's source code. Check the development agreement and applicable law separately.
If I am a repository admin, do I own its copyright?
An admin role gives platform permissions. Copyright ownership and licences are separate legal matters.
Is a ZIP file enough for handover?
A ZIP can deliver files, but a standard source download does not provide Git history or automatically include platform records and live services. Whether it meets the agreed delivery scope is separate from whether another team can build and operate the application.
Does owning the custom code mean owning its open-source packages?
No. Third-party components retain their own rights and licence conditions. The application must use them under the applicable terms.
Can a developer keep access after delivery?
Yes, where continued access is authorised for maintenance or another agreed responsibility. Define the purpose, permission level and process for changing or ending that access.
Is a working app proof that the handover is complete?
A working production app shows that the current setup runs. Handover also needs to establish the agreed access, documentation and ability to maintain or release it through the incoming arrangement.
Connect Rights, Access and the Ability to Operate
A clear arrangement identifies the rights your business holds, the resources it can control and the responsibilities delegated to its technical team.
For an MVP, defining these early makes later decisions easier. For an existing app, checking them reveals what another developer would need to continue the work.
If you are planning an MVP or preparing a provider transition, explore Damien Musy's expertise for a technical review of repository access, infrastructure dependencies and handover readiness.