A fix promised for Monday arrives three weeks later. The quote for a small change exceeds what the whole module cost. When you ask how the application is deployed, the answer is “it’s taken care of”.
Many companies stay in this situation for months longer than they would like. Not out of loyalty to the provider, but out of fear of what will happen when they leave. The application runs, your customers or your teams use it every day, and nobody on your side knows how to deploy it.
That fear is legitimate, but the risk drops sharply if the exit follows a precise order: recover what belongs to you, establish the real state of the software, organize the handover, and only then choose what comes next.

Is the problem really the provider?
A failing provider and a poorly managed collaboration produce the same delays and the same frustration. Changing providers only solves the first case.
Signs of a problem with the provider:
- Deadlines slip on simple tasks, with no technical explanation
- The team changes often and nobody knows the product’s history anymore
- You have no direct access to the code, only copies sent on request
- Releases regularly break features that used to work
- Your questions about the architecture get a vague answer, or a quote
Signs of a management problem on your side: priorities that change every week, requests made by phone with no written record, deliveries nobody validates. In that case, a new provider will run into the same difficulties. Our article on managing an external team covers these points.
For a business leader: if your provider stopped answering tomorrow, who on your side could deploy a fix to production? Without a clear answer, the priority is to take back control, whether you change providers or not.
Step 1: recover what belongs to you, before any announcement
While the relationship is normal, asking for admin access to the code repository is a formality. Once the break-up is announced, the same request can take weeks. This step must therefore come first.
What to check:
- The source code: admin access to the repository (GitHub, GitLab, Bitbucket), not an archive sent by email
- Hosting: AWS, Azure, OVH or other accounts, in your name and paid by your company
- The domain name and its DNS configuration, registered to your company
- Apple Developer and Google Play accounts, if you have a mobile app
- Third-party services: payment, email sending, maps, business APIs
- Secrets: passwords, API keys and certificates, stored in a vault you hold the key to
- Data: databases and backups, with a restore that has already been tested
- Documentation: architecture, deployment procedure, ticket history
Then reread your contract, on two points. Code ownership first: it is not automatic and depends on the rights assignment clause. If it is missing or unclear, consult a lawyer now. The notice period second: its length sets the handover timeline, so you avoid paying two providers longer than necessary, or being left with nobody for several weeks.
If a critical element is in the provider’s name, such as a cloud account or a domain name, have it transferred first.
Step 2: establish the real state of the application
An application can look good in a demo and be very hard to maintain. Before deciding anything, you need to know what you are taking over.
A takeover technical audit usually takes one to two weeks and answers five questions:
- Is the code complete? The application is rebuilt from the repository alone. Sometimes the production version contains changes made directly on the server and missing from the repository
- Can it be deployed? Is the release process documented and reproducible, or does it depend on one person?
- Are the versions still maintained? An application on PHP 7.4 runs on a version that has received no security fixes since November 2022, and Symfony 4.4 since November 2023. This lag does not stop the application from working, but you pay for it at the first change
- What is tested? Without automated tests, every change is checked by hand, and every oversight is discovered in production
- Where are the risks? Security flaws, passwords written in the code, parts nobody dares to touch anymore
The audit ends with a prioritized assessment and an effort estimate. That is the basis for the decision in step 4.
For a CTO: ask for the audit to rebuild and deploy the application in a fresh environment. If that deployment fails, you have found the first priority of the takeover, whatever the apparent quality of the code.
Step 3: organize the handover
Ideally, the outgoing provider stays available for two to four weeks after the new team arrives. This overlap is planned within the notice period, or paid separately.
During this period, four things should be obtained:
- A walkthrough of the architecture by the people who built it
- A production release done together, then another one done by the new team alone, under observation
- The list of known incidents, workarounds in place and work in progress
- The revocation of all the outgoing provider’s access at the end of the handover
This handover remains possible even when the relationship has become tense, especially if it is paid. Most providers prefer an organized exit to a dispute. For your next collaboration, our article on choosing a provider explains how to plan reversibility from the signature.
If the provider refuses any handover, a takeover is still possible. The new team rebuilds the knowledge from the code, the infrastructure and your business teams. Just allow a few more weeks.
Step 4: take over, stabilize or rewrite
It is often the first question asked, yet it can only be answered after the audit.
Take over as is, if the code is healthy, the versions are up to date and deployment is reproducible. After a few weeks of onboarding, development resumes.
Stabilize, then evolve, if the application works but remains fragile: few tests, outdated versions, manual deployment. The upgrade is done by priority, alongside urgent fixes.
Rewrite all or part of it, if the technology is abandoned or the architecture blocks any change. It is a project in its own right, carried out piece by piece while the old version stays in service.
A full rewrite is tempting: it promises a fresh start, free of the previous provider’s debt. But the current application contains years of business rules and special cases nobody documented. A rewrite forgets them, and your users then report them one by one.
In most cases, the takeover happens in steps: stabilize, add tests on the critical parts, then replace the most fragile components. The application stays in service throughout the work.
For an application generated with Lovable, Bolt or a similar tool, the approach is the same, with specific points of attention that we cover in vibe coding in production and in our AI-generated app takeover offer.
Which collaboration model after the takeover?
The model depends on what the application needs to become:
- A well-defined upgrade (framework upgrade, adding tests, automating deployment) suits a fixed-price project, with a set price and timeline
- An application that keeps evolving needs a dedicated team, which keeps the product knowledge from one release to the next (we describe how its launch is prepared)
- A stable application that mainly needs maintenance calls for application maintenance: fixes, security updates and small changes
The three often follow one another: a fixed-price project to get the application back on track, a dedicated team while the product evolves a lot, then maintenance.
How we take over an application at Etixio
We take over applications built by agencies, freelancers, internal teams or code generation tools. Where the code comes from matters less than access to the repositories, the infrastructure and the people who know the business.
We start with the audit and a full rebuild of the application in a fresh environment. Our tech leads then present the takeover plan, with priorities and costs. The work is carried out by our French-speaking engineers in Madagascar and Mauritius, with code review and tests at each release, in line with our commitments.
Accounts stay in your name and the code in your repositories. If you ever change providers again, including to leave us, you will not have to redo step 1.
Discover our technical audit or talk to us to assess the takeover of your application.
Changing IT provider: frequently asked questions
Do I own the code my provider developed?
Not automatically. Under French law, for example, the rights to software belong to its author unless a contract transfers them. Check the intellectual property clause of your contract, and get legal advice if in doubt.
Should I tell my provider before finding the next one?
It is better to secure access and everything that belongs to you first, then prepare what comes next. The relationship stays calmer when the exit is organized, with a timeline and a handover period, rather than announced in a rush.
How long does an application takeover take?
The takeover audit usually takes one to two weeks. What follows depends on the state of the code: a few weeks to stabilize a healthy application, longer if deeper work is needed. The takeover plan estimates each step.
Can an application be taken over without the previous provider’s documentation?
Yes, it happens often. The takeover then starts by rebuilding the documentation from the code, the infrastructure and discussions with your teams. It takes longer, but it is rarely a blocker.
Is it better to rewrite the application?
Rarely as a first choice. A full rewrite is expensive and loses business rules buried in the code. It makes sense when the technology is no longer maintained or when the architecture blocks any change. Otherwise, a gradual takeover is safer.


