Whoever takes over a system built by another company inherits what was never written down: the old bug, the rule that lives only in the database, the account in the name of whoever left. A vendor switch works when your company already owns the accounts (cloud, database, app stores, domain and repository) and when the new vendor diagnoses before promising: at GT, we fixed 15 inherited defects before changing anything else. And the exit can be planned on the first day of the contract, with the client as the owner of everything and the vendor as a member.
What the new vendor inherits when it takes over a system built by someone else#
A company that takes over a system inherits, along with the code, everything that was never written down: the bug the operation learned to work around, the rule that exists only in the database, the limit of a service bought years ago, and the account that stayed in the name of whoever left. A vendor switch works when these inheritances surface before the first promise, not after.
We write from the side of the company that arrives. Epicora has taken over systems built by other companies: GT's maintenance management platform, the UAI Legal system, which we only maintain, DNA Genética's old system, the management system of an audit firm, which we are replacing, and an electronic signature platform that came to us after the team that built it left.
In none of them was the whole inheritance in the code. At GT, the codebase came from the previous vendor with 15 defects. At DNA Genética, the tables that convert each animal trait by breed lived only in the old system's database. On the signature platform, the email plan in place capped sending at 50 messages per hour, a detail that shows up on no screen and matters to whoever starts running the system.
Why "the code is mine" is not enough: who owns the accounts#
Owning the code does not guarantee you can keep running the system. It runs in a cloud account, stores data in a database, is released from a repository, reaches the app stores through a developer account and answers on a domain, and each of those accounts has an owner. If the owner is the vendor that is leaving, the switch depends on that vendor's goodwill.

The code is usually the best protected part. In Brazil, article 4 of the Software Law (Law 9,609/1998) says that, unless agreed otherwise, the rights to software built under a services contract meant for that belong to whoever hired it. Rules differ from country to country, and in Brazil the "unless agreed otherwise" is the reason to read the ownership clause before signing. And no law puts the cloud, database or app store account in your company's name: that is settled at the moment each account is created.
The list of accounts behind an ordinary system is longer than it looks. At ProHire, the recruiting platform we built, the access survey covered the cloud (AWS), the database (MongoDB Atlas), billing (Stripe), invoicing (Focus NFe, a Brazilian electronic invoice service), both app stores, the app build service (Expo), Firebase and the domain, plus the repositories, the website hosting and the vault holding the secrets used to release. That is more than ten places, each with its own owner.
In the app stores, the standard we follow is that the client owns the app and publishes from its own developer account. Epicora joins as a technical member, Admin in App Store Connect and Release Manager in Google Play Console, and at the end of the project can be removed with no effect on the published app. What that account holds, and how to move one that was opened in the wrong place, is covered in who should own the App Store account.
What to ask the outgoing vendor for, and how to check each item#
The request to the outgoing vendor fits in a short list, and nearly every item can be checked without relying on anyone's word. One rule applies to every row: the account is in your company's name, the outgoing vendor appears as a member, and the check is done with a login of your own.
| What to ask for | Why it matters | How to check |
|---|---|---|
| The repositories for the whole system (API, website, app), with history | the history explains why the code is the way it is; a zip file loses that traceability | the GitHub or GitLab organization belongs to your company, with someone of yours as owner, and the latest commit matches what is live |
| The cloud account where the system runs | whoever owns the account decides whether the system stays up | the invoice is issued to your company and you sign in with your own user |
| The database and its backups | the data is the asset, and part of the business rules may live in it | read access to the production database and a backup restored in another environment |
| The domain and DNS | without the domain, the website, the app and email can stop | for a .br domain, Registro.br's public lookup shows the holder and its tax ID; for others, check the registrar account |
| The app store accounts | whoever controls the account controls the next version of the app | your company owns the Apple and Google accounts, and the outgoing vendor appears as a member |
| The accounts of paid services (billing, invoicing, email, SMS, push notifications) | the keys and contracts of these services keep the system working | a list with the owner of each account, checked in each service's dashboard |
| The inventory of secrets and settings | without them, nobody can release a new version | the names and location of each one, without the values, and rotation of the ones the outgoing vendor knew |
| The release pipeline | the system has to keep receiving new versions after the switch | the new vendor releases a version to staging before touching production |
| A description of how the system works today | it shortens the first weeks of whoever arrives | the description matches the live system, screen by screen |
| The list of known defects | it separates what already existed from the new vendor's work | each defect logged with current and expected behavior |
Nearly every row can be checked by your own company, as long as it owns the accounts. When it does not, the first request stops being the list and becomes the transfer of the accounts, before any other conversation.
When we are the ones answering this request, the format is the same. For a technical review of the electronic signature platform we maintain, we described how it works today (technologies, database, hosting, integrations and environments) and recommended read access to the repository rather than a zip file with the code, which removes traceability and widens the risk of uncontrolled copies. For database, cloud and integration credentials, the recommendation was not to share them.
Why the new vendor should diagnose before promising#
A company taking over a system should diagnose it before promising a timeline or a price, because the real system almost always differs from the one that was described. Diagnosing means navigating the live system, reading the code and the database, and logging the defects that already exist, so that the inheritance stays separate from the new work from day one.
At GT, the codebase inherited from the previous vendor had 15 defects. Each one was logged with current behavior, expected behavior and a screenshot as evidence, and all 15 were fixed before any new work, in 51 hours and 8 minutes. The rule we followed there was not to build on an unstable base.
Months later, to write two new GT modules, we surveyed the system in staging, navigating screen by screen and reading the API directly. The scope had been written from the client's material, and the survey corrected three assumptions: the calculation of how many checklist entries were expected per period already existed, the frequency setting was already in the form, and two indicators were already calculated, just not shown on screen.
At DNA Genética, the conversion tables the new system needed were only in the old system's database. We asked for read access to the production database, with a fallback plan of extracting the data through the application itself, and built the tests from real data taken from the live system and from a database backup. Not everything the system used was in the backup.
On the audit firm's management system, the diagnosis of the old system came before the quote: an immersion session with the client, a technical analysis of the system and a debrief, and only then the proposal.
Why a rewrite is not the first step#
Switching vendors does not require switching systems. A new vendor that proposes rewriting everything before touching the code is trading the diagnosis for a bet. The first step is to take the system over as it is, fix what blocks the operation, and decide later, once the team has lived with the code, what is worth keeping and what is worth rebuilding.
UAI Legal is a system built by another company that we only maintain: there is no new development, just a weekly check-in with the client and changes on demand. At GT, we rebuilt only the mobile app, which talks to the platform through a stable interface, and the web platform and the API stayed. The signs that an inherited system really needs replacing, and the ones that mislead, are in when a legacy system needs to be replaced.
The same rule applies when the inherited system was built with AI. Asking "what can be saved?" costs less than "let's rebuild it", as we show in what can be saved from AI-generated code. And anyone who built on a generator like Lovable can move the hosting and the database out without leaving the tool, as we explain in when an app built on Lovable needs to leave Lovable.
How to hand a system to another team without downtime#
A safe handover follows an order. The missing accounts are created in the client's name, the outgoing vendor prepares the system so it depends on nothing of its own, the code changes owner, a new version is released to staging and then to production, and only then is the outgoing vendor's access removed and the secrets it knew rotated.

That is the order we followed at ProHire, when the client moved the product to its own team in October 2026. Almost everything had been in the client's accounts from the start. Three items were left: the three code repositories, which sat in Epicora's GitHub organization, the website hosting, in Epicora's Vercel account, and the secrets vault the API release process read from a server of ours. The values the system uses were already in the client's cloud, so the vault only had to stop being needed.
Two technical details set the order. Transferring a repository on GitHub requires administrator access, according to GitHub's documentation, and at ProHire the person carrying it out had only write permission. And the permission that lets GitHub release to the cloud can name the repository: GitHub's documentation on connecting to AWS shows that condition, which limits which repositories get access. Without adjusting it first, releasing new versions stops right after the transfer. So we fixed the permission in the client's cloud first and tested in staging.
Credentials go through single-use secure links that expire, never by email or a loose spreadsheet. The website has to keep answering at the same addresses, because the app and the store listings point to the privacy policy published there. At the end, the outgoing vendor's access is removed, and we recommend rotating the passwords and keys it knew.
How to plan the exit from the first day of the contract#
The cheapest exit is the one planned before there is any reason to leave. It is decided at the start of the contract: each account is created in the client's name, the vendor joins as a member with the access it needs, the contract states who owns the code and what is handed over at the end, and the description of how the system works is kept up to date during the project instead of written in a hurry on the way out.
On the management system we are building for the audit firm, hosting in a cloud run by the client itself was decided during the technical visit, before the contract was signed. The client creating those accounts was a prerequisite for the first development stage.
The question also comes from the buyer's side. A prospect in a regulated industry asked in writing, in the document requesting proposals, for continuity if the vendor stops operating and for access to the configuration and source code. In our reading, the honest answer is not to promise to exist for decades but portability: full, periodic export in an open format with the attachments, and handover of the database and configuration at the end.
In the contract, four points settle most of the exit:
- Who owns the code, and handover of the repositories with their history at the end of the contract.
- Accounts in the client's name, with the vendor as a member, across cloud, database, app stores, domain, repository and paid services.
- A description of how the system works, kept up to date during the project.
- An assisted transition, with a deadline, credentials delivered through a secure channel and removal of the outgoing vendor's access.
What the warranty covers and what falls under support after delivery is another chapter of the contract, covered in what software warranty and support cover.
Frequently asked questions#
What should I ask my current software vendor for before switching?#
The repositories for the whole system with their history, the cloud account, the database and its backups, the domain, the app store accounts, the accounts of the paid services, the list of secrets and settings (names and locations only), the release pipeline, a description of how the system works and the list of known defects. Every account should be in your company's name, and every item can be checked with a login of your own.
If I paid for the development, do I own the code?#
It depends on the contract. In Brazil, article 4 of the Software Law (Law 9,609/1998) says that, unless agreed otherwise, the rights to software built under a services contract meant for that belong to the client, and the "unless agreed otherwise" is the reason to read the clause. Even with the code secured, the system runs on cloud, database, app store and domain accounts, and each one has its own owner.
Will the new vendor need to rewrite the system?#
Almost never as a first step. The vendor taking over should diagnose the live system, fix what blocks the operation and decide later what is worth keeping. At GT, we fixed 15 inherited defects before moving forward and rebuilt only the mobile app; UAI Legal, built by another company, we keep maintaining without a rewrite.
Do I need to change passwords after the old vendor leaves?#
It is the recommended practice. The outgoing vendor's access should be removed and the passwords and keys it knew should be rotated. In the ProHire handover, we recommended that the client rotate everything Epicora had seen, and almost none of those changes are noticed by the people using the system.
How do I check that the domain and the accounts are in my company's name?#
One by one, with a login of your own. For a .br domain, Registro.br's public lookup shows the holder and its tax ID; for other domains, check the registrant inside your registrar account. For the cloud and paid services, the invoice should be issued to your company. In the app stores, your company should own the developer account, with the vendor listed as a member.
Sources#
- Brazil, Law 9,609 of February 19, 1998 (Software Law), article 4 (unless agreed otherwise, the rights to software developed under the contract belong to the employer, the services client or the public body): https://www2.camara.leg.br/legin/fed/lei/1998/lei-9609-19-fevereiro-1998-364738-publicacaooriginal-1-pl.html
- GitHub Docs, "Transferring a repository" (transferring requires administrator access; issues, pull requests and the wiki move along, and old links redirect): https://docs.github.com/en/repositories/creating-and-managing-repositories/transferring-a-repository
- GitHub Docs, "Configuring OpenID Connect in Amazon Web Services" (the AWS trust policy condition that limits which repositories can assume the release permission): https://docs.github.com/en/actions/how-tos/secure-your-work/security-harden-deployments/oidc-in-aws
- Registro.br, public domain lookup (WHOIS) (shows the holder of a .br domain and its individual or company tax ID): https://registro.br/tecnologia/ferramentas/whois/
Next step#
If you are about to switch the company that maintains your system, or want to hire one with the exit already planned, that is the work we do in custom software: a diagnosis before the proposal and accounts in the client's name from day one, as at ProHire.
Want to look at this in your case?
Tell us in a few lines what you have today. We reply with the path that makes sense, even when the answer is not to build anything.

