Back to all posts
Source Code7 min read·October 25, 2026

Mobile App Source Code Handover: What Should You Receive?

TB
ThynkBlox Apps Team
App Engineering

A mobile app source code handover should give your business the code, account control and instructions another developer needs to build, release and operate the app. Use this mobile app source code handover checklist to check repository access, build instructions, dependency records, service ownership and credential transfer. Make acceptance depend on an incoming developer completing a clean-machine build and a controlled release rehearsal.

What should your mobile app handover include?

Treat the handover as a set of things you can verify, rather than a folder you acknowledge receiving.

AreaWhat to requestHow to accept it
RepositoryComplete code, change history and the version matching the live appYour business and incoming developer can access it
Build instructionsRequired tools, versions, setup steps and build stepsA developer follows them on a clean machine
DependenciesPackage records, locked versions, licences and private componentsEvery required component is available
ServicesAn account inventory with owners, billing and recovery detailsYour business can administer each required account
CredentialsSecure access to required secrets and release credentialsThe incoming developer can use their own authorised access
OperationsRelease, recovery, backup and support instructionsThe incoming developer rehearses the relevant steps

Keep a separate list of missing items, their owners and the evidence needed to close them. “Sent” and “verified” should be different statuses.

What repository access should you receive?

Request the working repository with its change history, rather than only a compressed copy of the latest code. Include the mobile app, any custom backend, shared components, automated tests and scripts required to build or release it. The publishing account matters too; see who should own your Google Play developer account.

Ask the outgoing developer to identify the version corresponding to the app currently available to users. Record unfinished work separately so the incoming developer can distinguish released behaviour from changes still in progress.

Check that your business controls repository administration and can grant or remove access. An invitation to view code is not enough if you still need someone outside your business to approve every future developer.

Ask for a written statement of what the handover includes and excludes. List third-party components and any code that remains subject to a separate licence. Keep the ownership agreement alongside the technical delivery; repository access and agreed rights to use the code are separate acceptance questions. Signing keys need the same care; see who should control your Android app signing keys.

What makes build instructions usable?

Build instructions should explain how to go from a fresh checkout to an app that runs on a test device.

Request:

  • Required development tools and their exact versions.
  • Supported operating systems and any platform-specific setup.
  • Steps to install dependencies and obtain private components.
  • Configuration instructions with example values that contain no secrets.
  • Separate instructions for development, testing and release builds.
  • Steps to run automated checks and install the app on a device.
  • Known setup problems and their confirmed fixes.

Ask the writer to remove assumptions such as “use the usual settings” or “copy the configuration from the old laptop”.

The incoming developer should record any undocumented step needed during setup. Add those steps to the instructions before accepting the build portion of the handover.

Which dependency records should come with the code?

Ask for both the dependency declarations and the records that lock their selected versions. Include components obtained outside the normal package installation process.

The dependency inventory should identify:

  • Public packages and the versions selected for the app.
  • Private packages and how your business obtains access.
  • Paid components, licence holders and renewal responsibilities.
  • Modified third-party code and a description of the changes.
  • Components with known maintenance concerns.

Avoid making a general upgrade part of handover acceptance. First establish that the delivered version builds and behaves as expected. Record proposed upgrades as separate maintenance work unless a dependency prevents the handover from being completed safely.

This gives the incoming developer a clear starting point. Our guide to what app maintenance involves after launch covers the ongoing work to plan after the transfer.

Which service accounts must your business control?

Ask for an inventory of every external service the app depends on. Depending on the app, this might include sign-in, stored data, notifications, payments, analytics, crash reports, email and app distribution.

For each service, record:

RecordAcceptance question
Account ownerDoes your business control administration?
Billing contactCan your business review charges and update payment details?
Recovery methodCan your business recover access without the outgoing developer?
App connectionIs it clear which part of the app uses this service?
Support accessCan the incoming developer investigate problems?
Transfer statusHas the required transfer or access change been verified?

Do not assume every account can be transferred in the same way. Require the outgoing developer to identify the applicable transfer procedure or document an alternative before sign-off.

For the release account, verify access to the existing app listing and its release settings. Use the Google Play release checklist to connect account handover with the steps needed for a future update.

How should credentials and signing access be transferred?

Keep secret values out of the article-style handover document, ordinary messages and the code repository. Request delivery through a secure credential-sharing method agreed by both teams.

Create named accounts for the incoming developer wherever supported. Review permissions against the work they need to perform.

Make signing and release access an explicit checklist item. Ask which credentials, keys or account permissions are required for each release route, who controls them and how access can be recovered.

Agree the order of the transfer:

  • Establish business-controlled administration and recovery.
  • Grant the incoming developer the required access.
  • Verify builds, service connections and release preparation.
  • Rotate credentials that were shared, where applicable.
  • Remove outgoing access once the transition is accepted.

Plan credential changes with the incoming developer so required app connections are updated and checked as part of the same work.

What should a clean-machine build prove?

Use a machine that has not previously been used to develop the app. The incoming developer should start with the repository, written instructions and newly granted access.

Define the acceptance test before starting:

  1. Obtain the agreed version of the code.
  2. Install the documented tools and dependencies.
  3. Apply the documented test configuration.
  4. Run the automated checks.
  5. Build and install the app on a test device.
  6. Exercise the agreed user journeys.
  7. Prepare a release build and rehearse the next release step in a controlled test channel.

For an illustrative booking app, the agreed journeys might include signing in, creating a booking, receiving a notification and viewing the booking again after reopening the app.

Record what passed, what failed and what required help. If the outgoing developer must supply an undocumented setting, update the handover and repeat the affected steps.

A successful build is one acceptance condition. Use the Android app testing guide to define the behaviour checks that accompany it.

What operating instructions should the next developer receive?

Ask for short instructions covering routine work and recovery:

  • How to publish an update and confirm it reached the intended channel.
  • How to inspect reported errors.
  • How to check that essential services are working.
  • How to back up and restore business data, where applicable.
  • How to respond to a failed release or service interruption.
  • Which known defects and unfinished changes remain.

Rehearse recovery steps in a test setting where practical. Record anything that has only been described, without verification, as an open acceptance item.

What common mistakes leave a handover incomplete?

Accepting a code archive as the whole delivery. Check the account, dependency and operational items alongside the code.

Testing only on the outgoing developer’s laptop. Require the incoming developer to complete the documented setup independently.

Leaving ownership checks until the end. Review service administration, billing and recovery early enough to resolve transfer restrictions.

Combining the transfer with a rewrite. Establish an accepted baseline before changing the architecture or replacing major components.

Signing off with vague exceptions. Replace “a few access items remain” with a named item, responsible person and acceptance test.

What else do founders ask about source code handover?

Is receiving the source code enough to change developers?

Use the full checklist. Your next developer should also have the required dependencies, service access, build instructions and release permissions before taking responsibility.

Should the incoming developer review the handover before acceptance?

Yes. Make their build and operating checks part of acceptance, and give them time to report missing information before the outgoing engagement closes.

Does every app need the same handover package?

No. Mark an item as not applicable only after confirming the app does not use it. An app without online services needs a smaller service inventory, but still needs build, dependency and release checks.

When should the handover be considered complete?

When the agreed checks pass, your business controls the required accounts, and every remaining exception has been explicitly accepted. Request a written acceptance record showing the evidence for each item.

Ready when you are

Planning an app of your own?

Tell us where your project is today. We will help you work out the scope before you commit to a budget.