Your company pays every month for a system it uses every day. One day, you need to switch vendors and discover that the repository sits in a personal account, someone else manages the domain, and nobody knows where the backups are configured.
The software works, but control lies outside the company.
This problem is more common than it seems. And it does not always stem from a poor relationship with the vendor: sometimes it starts with an account created quickly for a demo and ends up running production years later.
This guide helps you check who holds the keys to your system and what should remain under your company's control, whether you work with an in-house team or an external vendor.
Ownership and Control Are Not Exactly the Same
Legal ownership of the code matters, but it does not solve day-to-day operations by itself. You can have a favourable contract and still be unable to deploy because nobody has access to the server. You can also have access to the repository without holding the necessary rights to part of the development.
It is worth reviewing both dimensions:
- Ownership and usage rights: what the contract says about the code, documentation, design and other deliverables.
- Operational control: who can access the system, deploy, export data, restore the service and authorise someone else.
The exact legal position depends on the contract and each specific case. A qualified professional should handle the legal review; you can start the technical and operational checklist today.
The Repository Should Belong to a Company Account
The code should live in a GitHub or GitLab organisation, or on another platform controlled by your company. The vendor works within it using appropriate permissions, not the other way around.
Check at least:
- Administrator access for two people in your company, without sharing a single account.
- The complete repository, including its history, branches and release tags.
- The CI/CD configuration associated with the project.
- Access to issues or the work management system if it contains relevant decisions and requirements.
- A procedure for revoking access when someone leaves the project.
A ZIP snapshot of the code is no substitute for the repository. Its history explains how the system has evolved and makes it easier for another team to take over.
If you are not yet sure what to ask before signing a contract, see our guide on how to evaluate a software development vendor.
The Domain and DNS Are Part of the System
An application can be perfectly hosted and still become inaccessible because the domain expires or nobody can change the DNS.
Your company should know about and control:
- The domain registrar account.
- Billing and renewal details.
- The service that manages DNS.
- Certificates and their renewal process, even when it is automated.
- Recovery access and the mailbox that receives alerts.
The vendor can be the technical contact. The administrative contact and recovery mechanisms should allow your company to regain control without relying on one person.
The Cloud Account Is Not a Vendor Detail
AWS, Azure, Google Cloud, OVHcloud or another provider can bill your company directly while the technical team administers the service. This separation is usually healthier than concentrating ownership, billing and operations in an external account.
Review who controls:
- The main account or subscription.
- Production projects and environments.
- Billing and usage alerts.
- Administrator users and access keys.
- Activity logs and security notifications.
The vendor needs permissions to do its job, not necessarily ownership of the account. Access should be assigned to named individuals, follow the principle of least privilege and require MFA. A shared password that survives every team departure is not an acceptable alternative.
Your Data Needs a Way Out
Being able to log in to the application does not mean you control the data. The useful question is: can I extract a complete, understandable and usable copy without asking for permission every time?
Check:
- Which export formats exist and whether they include related data, not just an isolated table.
- Where documents, images and other files are stored.
- Who administers the database and backups.
- How historical data is retained and what information would be lost when switching systems.
- What delivery timescales and costs are specified in the contract.
Exports must be tested. A button that generates an incomplete CSV is of little use when you need to carry out a real migration.
If you are comparing building versus buying, this point is part of the total cost. We explore it in Custom Software vs SaaS.
Passwords Should Not Live in Chat or Code
Payment, email, mapping, messaging and other service APIs need credentials. These should be inventoried and stored in a secrets manager or corporate vault with controlled access.
The company does not need to memorise every secret. It needs to know:
- Which services exist and what they are used for.
- Who owns each account.
- Where credentials and recovery keys are stored.
- How they are rotated when the team changes.
- What each service costs and when it renews.
A secret pasted into the repository is not documentation: it is a security incident waiting its turn.
The Minimum Documentation Another Team Needs to Take Over
You do not need a two-hundred-page manual. You need useful, up-to-date information that is easy to find:
- Overall architecture: components, integrations and core data.
- Getting started: how to set up the development environment and run the tests.
- Deployment: what is deployed, where, and how to roll back.
- Operations: alerts, backups, scheduled jobs and known issues.
- Significant decisions: why certain solutions were chosen and what their limitations are.
- External inventory: domain, cloud, licences and third-party services.
The test is simple: a technical person who was not involved in the development should be able to understand the system and perform basic operations without reconstructing everything through trial and error.
What to Put in Writing with the Vendor
The relationship works better when an orderly handover is part of the agreement from the outset. Review the following with legal and technical advisers:
- Ownership of and rights to the deliverables.
- Use of proprietary, third-party and open-source components, including their licences.
- Accounts to be created in each party's name.
- Format and frequency of code and documentation delivery.
- The process for revoking access.
- Delivery of data, configuration and inventory when the engagement ends.
- Assistance during a transition and its terms.
Discussing an exit does not mean anticipating a dispute. It means both parties know how to work without turning dependency into a trap.
The Sixty-Minute Test
Set aside an hour with your team and answer using evidence, not memory:
- Can we log in as administrators to the repository, domain and cloud accounts?
- Do we know which services would stop working if the vendor disappeared tomorrow?
- Can we export the data and locate a recent backup?
- Is there enough documentation to deploy and operate the system?
- Can we revoke old access without disrupting the service?
- Are at least two people in the company able to authorise a recovery?
Every negative answer becomes a task with an owner and a deadline. You do not need to change vendors to gain independence: you simply need to organise the keys while everything is working.
In Summary
Controlling your software means much more than receiving some code at the end of the project. Your company should retain control of the repository, domain, infrastructure, data and critical access, supported by aligned contracts and documentation.
A good vendor does not need to retain you by closing doors. It can deliver more value by working with well-organised accounts, clear permissions and a handover that another team could pick up.
If you have inherited a system and do not know which accounts, risks or dependencies exist, we can help you map them and prioritise the fixes. Book a free initial consultation.
Keep reading: Code Audit: What We Review and What We Deliver, to see how a technical review becomes concrete decisions.