When a build ends

Software handover checklist: what you should receive when a build ends

A clean handover lets your team run, change and recover the software using accounts you control. Ask for code and history, documentation, tests, a working deployment pipeline and access to the systems the software needs. Verify the handover by having the receiving team deploy and restore the system before signing off.

Book a thirty-minute call

Short answer

Verify handover by having your team build, deploy and recover the software from the code, runbooks and accounts you control.

Best for

  • Founders ending an engagement with an agency or freelancer
  • Teams taking a project in-house
  • Buyers who want to avoid vendor lock-in
  • Anyone preparing for due diligence or an audit
  • Products that must outlive their first build team

Not for

  • Throwaway prototypes you never intend to maintain
  • Builds where you have deliberately retained the same vendor for life
  • Internal scripts with no production footprint
  • Work that has not reached a deliverable state yet
// 01

Compare the options

How to tell a clean handover from a lock-in trap.

Dimension Clean handover Vendor lock-in red flags
Code ownership

Repos in your org, with full git history.

Code lives in the vendor’s account, or a zip with no history.

Credentials

Client accounts are in control and service credentials are reissued or rotated.

Keys and logins stay with the vendor.

Infrastructure

Your organization controls the required hosting, DNS and monitoring accounts, with operating roles assigned.

The vendor is the only admin on production.

Documentation

Architecture, setup, and runbooks are written down.

Knowledge lives in the original developer’s head.

Tests and CI/CD

Automated tests and a pipeline you can run yourself.

No tests, or deploys only the vendor can trigger.

Lock-in

Any competent team can take over.

Only the original builder can change anything.

// 02

Where Wavect lands on this

The receiving team should be able to deploy and recover the software without the original developers.

We deliver code with its history in your repositories, alongside documentation, runbooks, tests and a deployment pipeline. Agree who controls each production account and how the receiving team will deploy, recover and change providers. A managed service may give you tenant-level access. Document its limits, how you export the data and who can authorize changes.

Let the receiving team run the rehearsal

Have someone who did not build the system start from a fresh checkout under the client’s organization. Ask them to follow the runbook, build and test the software, deploy to a safe environment and see an alert reach the new on-call owner. Restore a backup into an isolated environment and verify representative records and a key user journey. Record the elapsed recovery time and how much data would have been lost. Compare both with agreed recovery targets. AWS Well-Architected guidance on recovery tests.

A repository transfer can carry settings you still need to inspect. GitHub, for example, retains associated webhooks, secrets and deploy keys during a transfer. Check those, external runners, registries and deployment identities. Reissue or rotate credentials in the client’s accounts, test them and revoke replaced access. Record who owns renewals, billing and any licence or external service the software still needs. GitHub repository transfer documentation.

Use the data pipeline acceptance checklist to agree metric definitions, reconciliation, late records, safe reruns and reporting ownership.

// 03

Cost, risk and timeline

Cost Part of the buildThe agreed handover deliverables are included in the build scope.
Risk Lock-in if skippedA missed item leaves you dependent on the original builder.
Timeline Verified at deliveryRun the checklist before you sign off, not weeks later.
// 04

Where this usually goes wrong

  • Receiving a zip of code with no git history, so you lose the why behind every decision.
  • Discovering production secrets and accounts still belong to the vendor.
  • Finding the vendor is the only admin on hosting, DNS, or the database.
  • Inheriting a codebase with no tests and no runnable pipeline.
  • Relying on knowledge that lives only in the original developer’s head.
  • Calling the build done before anyone verified the handover items.
// 05

The checklist

Confirm every one of these before you accept the handover.

Tick items off as you go. Nothing is stored or sent.

// 06

What this looks like in our work

These cases describe products delivered to production. Use the rehearsal to verify your own handover.

These are selected projects, not our full portfolio. We have shipped 100+ products since 2018.

// 07

When this fits, and when it does not

// 01

When Wavect is the right fit

  • You want to own your software outright, not rent it from a vendor.
  • You may take the project in-house or to another team later.
  • You expect documentation, tests, and access as a default.
  • You want a builder who plans the handover from day one.
// 02

When we are not the fit

  • You want a vendor you will never be able to leave.
  • You see documentation and tests as optional extras.
  • You are building a throwaway prototype with no future.
  • You will not take ownership of your own credentials and infrastructure.

If you cannot run your software without the people who built it, you do not own it yet.

// 09

FAQs

The code in repositories you own, with the full git history. The history carries the reasoning behind every change, and a zip file without it throws that away. Everything else builds on top of that.
Move control of the accounts and replace the credentials used by the system. Give people named access and keep service credentials in the client’s secret manager. Verify that the new access works before revoking old credentials and removing vendor access that is no longer needed.
Anything that means only the original builder can change, deploy, or operate the software. Code in their account, undocumented systems, or admin access they will not hand over are all lock-in.
Yes. Without an automated test suite and a pipeline you can run yourself, every future change is risky and slow. They are what let a new team move safely after you take over.
Before you sign off on the build, not weeks later. Run the checklist while the original team is still engaged, so any gap can be closed immediately.
The agreed handover deliverables are included in the build scope. Agree any additional migration, training or support separately.
Book a thirty-minute call