Changing software provider: how to take back control
How to change software provider safely: put every account in your name, recover code, data and documents, get an independent review, then decide the next step.


Your business runs on an application that someone else built: a freelance developer, an agency, a small software company. Now that relationship is ending. The developer is moving on, the agency takes weeks to answer, or nobody returns your calls. You want to change software provider, but you are not sure what you actually hold: the code, the servers, the domain name, the data?
This guide is for managers in that position. We go through the order that protects you: get the accounts in your company’s name, recover what belongs to you, have the code reviewed by someone independent, keep the application running during the handover, and only then decide whether to maintain, refactor or rebuild. A handover checklist closes the article.
Before you change software provider: know what you need to get back
The real risk in a change of provider is rarely the code itself. It is access. If the hosting account, the domain name or the code repository sits in your provider’s name, you do not control your own application, even if you paid for every line of it.
Start by reading two things:
- Your contract. Look for what it says about intellectual property, the source code, the handover at the end of the contract (often called reversibility) and the notice period. Our guide on choosing an IT provider lists what a good contract should contain; if yours is silent on some of these points, note them for your lawyer.
- Your invoices and accounts. Who pays for the hosting, the domain and the app store memberships? The name on the invoice often tells you who holds the account.
Who owns the source code depends on the contract and on the country whose law applies. In many countries, the person who writes the code holds the rights unless a written agreement transfers them, even when the client has paid. The rules differ from one country to another, and from employees to contractors.
This article gives practical, general pointers as of October 2026. It does not replace advice from your lawyer, who should confirm your rights under your contract and the law that applies to it.
Take back the keys: accounts, code, data and documentation
Put every account in the company’s name
Make a list of every service your application depends on, then move each account to an email address your company controls (for example, a shared IT address rather than one person’s mailbox):
- Code repository (GitHub, GitLab, Bitbucket or similar): the company should own the organisation or workspace, with the provider invited as a member.
- Hosting and cloud accounts: servers, databases, file storage, backups.
- Domain name and DNS (the settings that point your domain to your servers): the registrar account must be yours, with the renewal on your card.
- App stores: the Apple Developer and Google Play accounts that publish your mobile apps. Moving an app from one account to another is possible but takes formal steps on each store, so start early.
- Third-party services: email sending, payments, maps, text messages, error monitoring, analytics. Each one has its own login and its own keys.
The safe order is simple: add your company as an owner first, check that you can log in, and only then remove the provider’s access, once the handover is finished.
Recover the code, data and documentation
A zip file of the code is not enough. Ask for:
- the full repository with its history, so the next team can see how the code evolved;
- a database export and the description of its structure;
- the uploaded files your users have added (documents, images);
- the build and deployment instructions: how to go from the code to a running application;
- the list of secrets and settings (passwords, API keys, environment variables), handed over securely, never by plain email;
- the documentation that exists, the list of known bugs and any work in progress.
The real test: can someone who has never seen the project build it and deploy it from what you received? If not, something is missing.
Have the code reviewed by someone independent
Once you hold the code, have it looked at by someone who did not write it and is not yet selling you the next project. An independent review answers practical questions:
- Does the code build and run from what was handed over?
- Are the language, framework and libraries still supported, or close to the end of their support?
- Are there automated tests, and do they pass?
- Are there obvious security weaknesses, such as passwords in the code or data reachable without a login?
- How much of the application depends on knowledge that only one person had?
This is a short version of an IT audit, focused on one application. At AnazTech, we offer this audit on quote: we propose it at the end of the discovery call, once we understand your situation.
Keep the application running during the handover
Your users should notice nothing. A few habits keep the handover quiet:
- Overlap where you can. A short period when the outgoing provider still answers questions saves a lot of guesswork.
- Freeze new features. During the handover, only fix what is broken. New work waits until the new team knows the system.
- Check the backups. Make sure a recent backup exists, that it is stored on an account you own, and that someone has actually restored it once.
- Write down who to call. For each service (hosting, domain, payments), note who has access and how to reach support.
- Watch the application. Error alerts and a simple uptime check should go to your company, not only to the provider.
Maintain, refactor or rebuild?
With the review in hand, you can decide. Do not let anyone push you to rebuild before you know what you have. If this choice competes with other projects for the same budget, an IT roadmap that ranks projects on value, effort and risk helps you set the order.
| Option | When it fits | What to watch |
|---|---|---|
| Maintain | The code is sound, the technology is supported, the application does what you need | Agree on response times and a monthly budget for fixes and updates |
| Refactor | The application works but is hard to change: old versions, no tests, tangled code | Improve it step by step, without stopping the business |
| Rebuild | The technology is no longer supported, or the application no longer fits how you work | Recover the data properly and check the new version does what the old one did |
If you maintain, put in writing what the maintenance contract should cover, from updates to response times. Our article on technical debt and modernisation explains how to refactor in steps. If you rebuild, plan the data migration early and use parity testing to prove the new application behaves like the old one.
At AnazTech, we take over existing applications in three ways: maintenance by monthly subscription, modernisation, or a new custom software project when rebuilding is the honest answer.
Software handover checklist
Use this list before you end the contract:
- Contract reread: intellectual property, source code, reversibility and notice period noted; questions sent to your lawyer
- Code repository owned by the company, provider invited as a member
- Hosting, database and file storage accounts in the company’s name
- Domain name and DNS in the company’s name, renewal on a company card
- Apple Developer and Google Play accounts transferred or transfer started
- Third-party services listed, with their owner and their keys
- Full repository with history received
- Database export, structure and uploaded files received
- Build and deployment instructions tested by someone else
- Secrets and settings handed over securely
- Documentation, known bugs and work in progress received
- Backup restored at least once, stored on a company account
- Error alerts and uptime checks sent to the company
- Independent code review done
- Provider’s access removed, after the handover
Frequently asked questions
Who owns the source code of my application?
It depends on your contract and on the law of the country that applies to it. In many countries, the developer keeps the rights unless a written agreement transfers them to you, even if you paid for the work. Check the intellectual property clause of your contract and ask a lawyer to confirm what it means where you are. For a future project, choose a provider whose contract settles this clearly from the start.
Can a new provider take over a software project without the previous one’s help?
Often yes, as long as you hold the accounts, the code and the data. The previous provider’s help makes the handover faster, because they know where the traps are. Without it, the new team rebuilds that knowledge by reading the code, testing the application and asking your users how they work. That is why the accounts and the code come first: without them, a takeover becomes a rebuild.
Should I tell my current provider before looking for a new one?
You can look for options quietly, but secure the accounts before announcing anything. Ask for the transfers as normal good practice: putting accounts in the company’s name is reasonable whatever happens next. Then give notice as your contract requires, in writing, with a clear list of what you expect to receive. A calm, factual request keeps the relationship workable during the overlap.
In short
Changing provider is mostly about control, not code. Put every account in your company’s name, recover the code with its history, the data and the documentation, and test that someone else can deploy it. Have an independent review, keep the application running during the handover, and only then choose to maintain, refactor or rebuild.
Your application depends on a provider you can no longer reach? Book a free 30-minute discovery call: together, we look at what you hold today and what to secure first.
Related servicesCustom softwareModernisation
Let’s talk about it on a 30-minute discovery call, free and with no obligation.
Get our next articles in your feed: follow AnazTech on LinkedIn.Follow on LinkedIn






