Business owners often discover what they do not hold on the worst possible day: the vendor who built the system stops answering messages, the phone number goes dead, or the company has closed. The system still runs and customers still use it. But nobody on your side can log in to the server, open the code, or knows how to ship a fix.

This is rarely about bad intent. A vendor changes jobs, a team breaks up, a freelancer falls ill, or a contract ends on cold terms. The real cause is almost always the same: the keys to the system were held by the people who built it from day one, and never changed hands.

Our view is blunt. A system built by a vendor is only really yours to the extent that you hold three things: its accounts, its code, and the notes on how it works. All three should sit with the business owner from the first week of the project, not on handover day.

Comparison of who holds the accounts, code, and deploy steps: the vendor or the business owner

Key one: accounts in the company's name

Hosting, domain, cloud services, database, transactional email, payment gateway: all of these should be registered to your company, using an email address the company manages. The vendor joins as a user with the access it needs, and you can revoke that access at any time.

Accounts registered to a developer look convenient at the start. The trouble comes later, because billing notices, password resets, and verification codes all land in someone else's personal inbox. AWS's guidance on the root user points the same way: use an email address managed by the business that forwards to a group of people, so the account owner can still be reached when someone is on leave, ill, or has left the company. The principle applies to any account, not only AWS.

Six accounts that must belong to the company: hosting, domain, code repository, cloud and database, email and payments, password manager

Key two: code in a repository you own

The source code should live in a repository owned by your organisation, for example a GitHub or GitLab organisation registered to the company. The vendor's team works inside it as collaborators. You are not waiting for an archive of code at the end of the project; the vendor is working in your house.

One small detail often gets missed: the number of owners. GitHub recommends at least two people hold the owner role in every organisation, so access to projects is not lost when one person cannot be reached. Make sure both are on your side.

Rights to the code are a contract matter and should be spelled out there, including any internal vendor components that are licensed rather than transferred. But without real access, even a well-drafted clause is hard to use in an emergency.

Key three: notes another developer can read

Documentation is the key that gets postponed most often. The test is simple: could a developer who has never seen this system work on it from the documents alone? The minimum content:

  • how to run the system on a new machine, from scratch
  • how to deploy to production, step by step
  • a list of accounts and services: who owns each and who has access
  • where the data lives, the backup schedule, and how to restore it
  • third-party integrations and who registered them

Passwords do not belong in that document. Keep them in a password manager owned by the company.

When to hand over: week one

The reason is practical. On handover day the project is finished, the budget is spent, and your bargaining position is at its weakest. Asking for access then feels like making a demand. If access has been there from the start, there is nothing to demand. Documents written along the way are also far more accurate than ones rushed out of memory on the final day.

Handover timeline: week 1 accounts and repository, week 2 first document, each release the document is updated, before go-live the vendor-gone drill

Prove it with a "vendor-gone" drill

The way to know it all works is to try it. Pick another developer or someone on an internal team, give them only the access and the written documents, and ask them to deploy the system from scratch to a test environment, not to production. Every point where they get confused is a hole in the documentation. Fix it now, while the vendor is still easy to ask.

Four steps of the vendor-gone drill: pick someone else, give only what is written, ask for a deploy from scratch, note where it stalls

If the vendor objects

Not every objection is a red flag. Full production access can be opened in stages for security, and a vendor's internal libraries are reasonably covered by a written licence. But "later, once we are done" or "relax, we hold it", with no date and no technical reason, is an answer worth questioning again. A vendor doing good work has no reason to object to accounts in your name, code in your repository, and documents that can be read.

That is the standard we use at XETUP, and it is a fair test for any vendor, including us. If you want to know where your system stands today, we can help through an Initial Audit: bisnis@xetup.id or WhatsApp +62 822 6515 7644.