If your mobile app was started by a freelancer, an agency or an in-house developer who has since left, stopped replying or handed over something unfinished, you still have options. Taking over an unfinished mobile app from a previous developer in Canada is often possible when the code and accounts can be recovered. A new team needs three things: the code, the accounts that run the app, and a build that runs from the repository. This guide covers how to get each one in writing before anyone changes a line of code. The Apple and Google steps are the same for account holders in New York, Austin, Raleigh and Denver. The copyright section is Canadian, and US readers should check it with a lawyer in their state.
Can you take over an unfinished mobile app from a previous developer in Canada?
Often, yes, provided the code and accounts can be recovered. The audit described below is how you find out. Three terms first:
- Takeover: a new team accepts responsibility for the app as it stands and carries it forward.
- Handover: the transfer of code, accounts, documentation and access from one party to another.
- Rebuild: writing new code for some or all of the app. A rebuild often reuses the designs, content, data and lessons from the earlier work.
Some terms you will meet in the rest of this guide:
- Repository: the online home of the code, usually on GitHub, GitLab or Bitbucket. It keeps the full history of every change.
- Backend: the part of the app that runs on servers. It handles logins, stored data, payments and push notifications. Users never see it, but the app can't work without it.
- Firebase project: Google's container for an app's backend tools, such as logins, databases and push notifications. A Supabase project is a comparable hosted service.
- API key: a secret string that lets the app or server use a service on your account. Anyone holding it can act as you on that service.
- Bundle ID and package name: the unique identifiers Apple and Google use for your app, such as com.yourcompany.appname. Changing one tells the store that the app is a different app.
- Signing key: the cryptographic key that proves each new version of the app comes from the same publisher.
Earlier teams stop for many reasons: a contract ends, a fee is disputed, priorities change, or a small studio takes on more than it can deliver. Those reasons say little about what you have. The question is what you can recover, and what it is worth.
Check account ownership before anyone writes code
Accounts decide everything else. A new team can write sound code and still be unable to publish it, deploy it or keep it running if a key account sits in someone else's name.
For each account, record what it does, who the account owner is, which login the business controls, who pays the bill and when it was last paid. The accounts to check are:
- Source repository
- Hosting and servers
- Domain name and DNS: your web address and the records that point it to the right place
- Database and backend services
- Analytics and push notification services
- Apple Developer and Google Play Console accounts
If you can't find a login, record that too. A missing login is a finding for the audit, not a reason to stop.
Source code and repository access
Ask for repository access under an account the business controls, along with the full commit history and the build scripts. A zip file is not a handover.
A zip is a snapshot. A repository shows history: what changed, when, and what the earlier team wrote in each commit message. That history explains why a payment flow was built the way it was, and whether a half-finished screen was abandoned or never started. It also shows whether anyone maintained the code after launch.
Ask for a short setup note too: the tools and versions the app needs, the settings it reads from its environment, and the steps to start it. If those are missing, the audit has to reconstruct them, which costs time you would rather spend on the app.
Apple Developer and Google Play accounts
Treat the store accounts as the keys to the shop. The listing, its ratings and reviews, its download history and any in-app purchases all sit under them.
On Apple, the Account Holder is the person or organization that enrolled the company in the Apple Developer Program and agreed to its terms. The Account Holder can add team members, sign agreements and start an app transfer. If the earlier developer is the Account Holder, the business should plan to take control of that account. Google Play has its own owner and user roles, so check who holds the owner role.
Check the annual developer program fee on developer.apple.com rather than relying on an old invoice or a blog post.
Here is a hypothetical example. A Denver company publishes its app under a contractor's personal Apple account. The app works and the users are real, but the company can't change banking details, add a team member or start a transfer until the contractor cooperates. Fixing that before the audit costs far less than fixing it during a launch.
Backend, hosting and third-party services
The mobile app is the part users see. The backend does the work behind it, and it's where handovers often go wrong. Common pieces include Firebase, Supabase, a Node.js server, a payment provider, a domain and transactional email, such as password resets and receipts. For each one, check who the billing owner is, who holds the admin logins and whether backups are running.
Rotate the secrets after the handover. A working API key on the earlier team's laptop, in an old email or in a shared document still gives them access to your data. Rotate the keys, change the passwords and remove former team members' access. These steps are part of the handover, so put them in the plan from the start.
If the backend needs a new or replacement server, our VPS setup and hardening service configures and secures it before it goes live. If the app has a companion web dashboard or admin panel, our web development team can take that on in the same handover.
Who owns the code after a mobile app takeover in Canada?
Copyright in code generally starts with its author, and this is where many takeovers go wrong.
Under Canadian law, an employer usually owns the copyright in work an employee creates in the course of their job. A freelancer, contractor or agency generally keeps the copyright in what they write, unless the contract says otherwise. Paying the invoice does not, by itself, transfer the copyright.
Section 13(4) of the Copyright Act says the owner of copyright may assign it, but no assignment is valid unless it is in writing and signed by the owner or the owner's duly authorized agent. A promise in a chat thread or a verbal “it's yours” does not meet that test. The current consolidated text is at laws-lois.justice.gc.ca.
This is general information, not legal advice. Get advice on your own facts before you sign anything.
A licence to run the app is not code ownership
Many agreements give the client a licence to use the app, sometimes only the compiled version on users' phones. That licence lets you run the app. It may not let you see, change or hand over the source code. Read what you actually signed, because the wording decides what you own.
Moral rights and waivers
Canadian law also recognizes moral rights, including the author's right to be credited and to object to changes that harm their reputation. Moral rights cannot be assigned, but an author can waive them. Many handover agreements ask for a waiver, and a badly drafted one can cause trouble later. Have a lawyer review any waiver before you sign.
What the signed assignment should contain
Ask for a signed copyright assignment as part of the takeover. It should identify the code (by repository and version), the design assets, the icons and the written copy, and it should carry the date and both parties' names. A template is a starting point, not a finished agreement. Have a Canadian IP lawyer adapt it to your situation.
US readers face the same principle. US copyright law also requires a transfer to be in writing and signed by the owner (17 U.S.C. § 204(a)). A startup in New York, Austin, Raleigh or Denver should have a lawyer in its state check the wording before signing.
What to ask the previous developer for in writing
Keep the request neutral and factual. You are asking for what a new team needs to continue the work:
- A signed copyright assignment covering the code and assets.
- A list of deliverables: what was built, what was agreed, and what remains.
- The status of any invoices: paid, unpaid or disputed.
- The open-source libraries the app uses, with their licences. Some licences, such as the GPL, carry obligations if you distribute the app, so they need checking.
- Any third-party code with restrictions, and any services set up under the earlier team's logins.
- Known issues, and where the work stopped.
- The access details needed to transfer accounts.
A short request is enough: “We are taking over the app for our business and need the following to continue the work. Could you confirm by [date]?” If the reply is slow, set a reasonable deadline in writing.
If the previous developer will not hand over the source code
Without the source, you can't properly audit, fix or finish the app, and the options narrow. Check whether any of the code sits in a repository, cloud account or machine that your business can reach, and whether it was paid for under a written agreement that includes an assignment. If it doesn't, get legal advice before you rely on the app as your own.
A rebuild may still be possible. Reusing designs, copy and other assets depends on who owns them, so get that position checked before anything is reused. The audit will show you which designs, content and data you hold.
When the previous developer has gone quiet
Start with everything you already control: your business email, your domain registrar, cloud accounts billed to your company card, and any Apple or Google account you already hold. Write down what you can reach and what you cannot.
A clear account record often lets a new team move forward without the earlier developer. Where code sits in an account you can't reach, or the copyright position is unclear, don't guess. Get legal advice before you rely on code you can't show is yours. Keep a dated log of every attempt to make contact. If the matter becomes a dispute, that log is what counts.
Start with a written audit, not a fix
The audit is the first paid step, and it happens before any change to the live app. Changing code nobody has examined is how small problems turn into expensive ones.
An audit means running the existing app and writing down what it actually does. It covers:
- Whether it runs: does the project build and start from the repository, without guesswork?
- Dependency age: how old the libraries and frameworks are, and whether they are still supported.
- The data model: how the app stores users, orders, content and permissions.
- Security basics: secrets stored in the code, exposed keys, unencrypted personal data, and who can see what.
- Test coverage: whether there are automated tests, and which parts of the app they check.
- Third-party services: what each one does, who owns it and whether it is still active.
The output is a written handover note and a fixed-price scope for the next phase. Whoever you hire, insist on that order: audit first, then a price for the work the audit describes.
What a useful audit report contains
A useful report says what runs, what breaks and what is unfinished. It ranks risks: high for security or data loss, medium for a core flow that breaks, low for tidy-up work. Each problem comes with steps to reproduce it, so your own team can check it. The report ends with a recommendation to fix, finish or rebuild, and the reasons for it.
A good report lets you compare quotes on the same facts. If two teams price the same app and only one has seen the audit, the quotes can't be compared.
How long an audit takes and what it costs
Timing depends on the app's size, how well the earlier work is documented and how many outside services it connects to. A small app with a clean repository is a different job from a large app with several backend services and no notes. We don't quote a timeline in the abstract. Agree a start date and an end date in writing before the audit begins, and put in the scope what the audit covers and what it doesn't.
Cost works the same way. The audit and each later phase are priced as a fixed price in a written scope, agreed before work starts.
Fix, finish or rebuild: how to decide
The audit gives you the facts, and the table below turns them into a rough call. These are rules of thumb, not promises. The audit's written findings make the final decision.
The stack matters less than whether the project builds and runs on supported versions. Flutter, React Native, Expo, Swift and Kotlin projects can all be audited the same way.
| Factor | Points to fix or finish | Points to rebuild |
|---|---|---|
| State of the code | Builds and starts from the repository with a documented setup | No clean build; setup depends on one person's machine |
| Framework and versions | Mainstream stack (React Native, Expo, Flutter, Swift, Kotlin) on supported versions | Framework or core library is abandoned, or too old to update without rewriting most of it |
| Store status | Live with a working release, so updates can ship on top of it | Listing can't be recovered, or the app was never submitted and its design has changed substantially |
| Planned scope built | Core user flows work end to end; missing parts are clearly defined | Core flows are missing or exist only as mockups; most of the planned scope is still ahead |
| Data model | Structure supports the planned features with changes | Structure can't support the planned features without a full reshape |
| Security | Problems are local and fixable, such as moving keys out of the code | Security problems run through the core design, such as users seeing each other's data |
| Documentation and tests | Some notes or tests exist, so intent can be recovered | Nothing written down, no tests, and intent can't be reconstructed |
| Ownership | Code and accounts can be established in writing | Ownership can't be established; pause until a lawyer resolves it |
| Budget | Covers an audit and a phased fix or finish | Covers only a fix that won't reach the planned features |
Signs it is worth fixing or finishing
- The project builds and runs from the repository.
- Core user flows work: sign-up, the main purchase or booking, and the screens users see most.
- The stack is mainstream, such as React Native, Expo, Flutter, Swift or Kotlin. A new team can work in these without learning a new system.
- The app is already in the stores and has users.
- Some documentation or tests exist.
Apps built in AI-assisted tools such as Lovable, Replit, Bolt or Cursor need the same checks, with three questions added. Can you export the code? Does it run outside the platform? Can you move the backend, accounts and data into your name? If the answers are yes, finishing is a real option. If the app only runs inside the platform, the audit will say so, and the recommendation will follow from that.
Signs a rebuild is the honest answer
- No one can get a clean build, and the setup can't be reconstructed.
- Framework versions are abandoned, and updating them means rewriting most of the app.
- The data model cannot support the features you now need.
- Security problems run through the core design, rather than one or two spots that can be patched.
- Code ownership can't be established, and a lawyer has to resolve it before anyone builds on it.
A rebuild is not a write-off. It can reuse designs, content, API contracts (the agreed rules for how the app and server exchange data), analytics and what you have learned about your users. If the designs need rethinking, our UI/UX design team can help. If the audit points that way, a rebuild can be scoped with the same written approach as a fix, through custom software development for a rebuild.
Mixed cases: stabilize now, rebuild in parts
Where the audit finds a live app with some sound parts and some broken ones, the usual answer is to stabilize the live app first, so users don't meet crashes or broken payments. Then rebuild modules in phases, starting with the parts that cause the most trouble or hold back the most features.
Each phase needs its own written scope, fixed price and launch date before work starts. That is the main protection against a mixed project drifting off course.
Transfer the listing to your Apple and Google accounts
Store transfers are the most time-sensitive step in a takeover. A transfer moves the existing listing, along with its ratings and reviews, to your account. Republishing from a new account starts a new listing with no history. Make that choice on purpose, before anyone clicks through a console.
Apple: how the transfer works
Published guides describe the process this way: the Account Holder of the old account starts the transfer, and the receiving account has 60 days to accept it. They also say ratings and reviews carry over with the app. Confirm both points in App Store Connect before you plan around them, and check the current transfer criteria there, because Apple's rules can change.
Verify these details in App Store Connect rather than from a blog post:
- Processing time: sources disagree on how long a transfer takes. Don't plan a launch around a figure you haven't confirmed on Apple's own pages.
- Eligibility: Apple sets criteria for which apps can be transferred.
- Banking and tax: if the app sells in-app purchases, banking and tax information must be fully set up on the accounts involved. Check the requirements on developer.apple.com.
- The developer program fee: confirm the current annual amount on developer.apple.com.
Keep the bundle ID unchanged through the transfer, because a different bundle ID tells the store it is a different app.
Google Play: registration IDs and signing keys
Some guides say a Google Play transfer needs a registration transaction ID for both the old and new accounts. Confirm the current requirement in the Google Play Console help or with Google Play support before you start. Collect whatever it asks for early, so the transfer doesn't stall while you search for it.
The signing key proves that each new version comes from the same publisher. If it is lost, or held by someone who won't cooperate, you may be unable to publish updates to the same listing. Document where the key is kept, store it in a secure vault, and make sure at least two people in the business can reach it.
Google's Play App Signing service includes a process for resetting an upload key. Check the current Google Play Console help for the exact route before you choose one, because the steps change over time.
If the previous developer will not cooperate
Republishing from your own accounts is the fallback. The trade-offs are real:
- Ratings and reviews don't carry over. The new listing starts from zero.
- Existing installs may not update. On Google Play, the package name is fixed once an app is published, so a new package name is a different app. On Apple, a new bundle ID does the same.
- Users need a clear message: what is changing, why, when to switch, and how to restore purchases.
If the dispute involves access to accounts or code, get legal advice before acting. Keep every message to the earlier team neutral and factual, and keep dated records.
Keep subscriptions and payments working through the handover
Paying users are the biggest risk in a takeover. A broken purchase flow costs revenue and trust, and both are hard to win back.
Start by mapping where each payment sits:
- In-app purchases on Apple and Google are tied to the store accounts. They don't move with your code.
- Subscriptions run through a payment provider such as Stripe are separate. They live in the provider's account, and your backend records which users have paid.
- Entitlements are the records that say a user has paid. If the backend loses them, paying users can lose access even though the money has moved.
Then plan the cutover around your users:
- Restore purchases: the control that lets a user recover their purchases on a new phone must keep working. Test it.
- Sandbox testing: test purchases in Apple's and Google's test environments before anything goes live.
- No gap in access: plan the cutover so paying users keep access throughout.
- Transfer behaviour: don't assume subscriptions move the same way as the listing. Confirm how in-app purchases behave during an account transfer against the store documentation, and test with a sandbox account first.
If the takeover needs a team to finish the app and its payment flow, our mobile app development services cover iOS and Android apps.
Backend, hosting and data: what changes hands
The backend needs a clear owner, billing, backups, monitoring and rotated secrets. Work through each one:
- Ownership: each service belongs to a business account, with at least two people who can administer it.
- Billing: check who pays for each cloud account, and move those accounts into the business's name. A hypothetical Austin company whose backend is billed to a former developer's card could see the app go offline the day that card expires.
- Backups: confirm backups are running, and test a restore. A backup you have never restored is a hope, not a plan.
- Monitoring: set up alerts, so you hear about a failed server or database before your users do.
- Data location and access: ask where user data is stored and who holds administrator access. Canadian privacy law and your own customer commitments both depend on that answer.
Our cloud setup and migration service covers the move into your accounts, including the architecture and cost controls. For a wider view of the move, see cloud migration services in Toronto.
How Eskore runs a takeover
We keep to what we can stand behind:
- Written scope, fixed price and launch date are agreed before work starts. You know what is being delivered, what it costs and when it goes live.
- One team for software, design, cloud and marketing. The app, backend, design and hosting are handled by the same people, so nobody is left arranging hand-offs between separate vendors.
- You own the code and the accounts. Repositories, store accounts, hosting and domains stay in your business's name.
- Offices in Toronto, Thornhill, London and New York.
We recommend a written audit before any change, and we'd suggest the same to any team you hire. If the audit points to a rebuild, we scope it the same way: written, fixed and dated. You can see past projects in our case studies.
Next steps for your mobile app takeover
If you are weighing up a takeover of an unfinished mobile app from a previous developer in Canada, start by gathering your account list, repository access and store account details. Gaps are useful information too. We'll work through them on a free 30-minute scoping call, so book your call on our contact page.