StackLift
All playbooks

Playbook

Software Handover Checklist

A clean handover means the receiving team can run, change, and hand off the software without the builder. This checklist covers ownership, access, documentation, and proof.

Best reader

Founders and technical leads receiving software from a vendor or handing it to another team

Outcome

Full ownership of code, accounts, and knowledge, verified by the receiving team.

Use this sequence

1

Move repositories into accounts the receiver controls.

2

Transfer cloud, domain, store, and third-party accounts to organization identities.

3

Rotate every credential the previous team could still use.

4

Hand over documentation, architecture notes, and runbooks.

5

Have the receiver deploy from scratch using the documents.

6

Run a walkthrough covering known issues and open work.

7

Sign off, then keep a short support window for questions.

Ownership first, audit second

Make sure the receiving organization owns the repositories, hosting, domains, and app store accounts before reviewing anything else. Accounts tied to one person's email cause trouble later.

Repositories with full history

Cloud and hosting

Domains and DNS

Store and third-party accounts

Credentials and access

Credentials are where handovers quietly break. List every secret, move it to managed storage the receiver controls, then rotate it so the old team's copies stop working.

Secrets inventory

Rotation

Removal of old access

Admin accounts

Verify, do not assume

Each checklist item should have a test the receiver runs. The strongest one is a fresh deploy and a rollback by the receiving team, using only what was handed over.

Fresh deploy

Rollback

Restore from backup

Walkthrough

Start in 60 seconds

Turn this checklist into a scoped plan.

Answer a few questions and get an AI-assisted, architect-reviewed scope, cost range, and timeline for your software project.

Frequently asked questions

What should a software handover include?

Source code with history, infrastructure and account ownership, secrets, deployment and runbook documents, architecture notes, test suites, and a list of known issues and open work.

When should you plan for handover?

At the start. Ownership terms belong in the contract, and keeping code and accounts in your own organization from day one makes the final handover small.

The complete guide

Software Handover Checklist: the complete guide

Updated November 18, 2026 ยท Published by , Founder, StackLift AI. Written with AI assistance; how we make content.

Short answer

A software handover checklist makes sure the receiving team can run, change, and hand off the software without the builder. It covers repository ownership with full history, cloud, domain, and store accounts, rotated credentials, documentation and runbooks, a fresh deploy and rollback by the receiver, a walkthrough, and signed acceptance.

What is a software handover and what does done look like?

A software handover moves responsibility for a system from one team to another. The giver may be a vendor finishing a build, a departing team, or a previous agency. The receiver may be your in-house team, a new vendor, or you.

Handover is done when the receiving team can run, change, and hand off the software without the original builder. That is a higher bar than receiving a zip file. It includes the code, the accounts, the secrets, the knowledge, and proof that all of it works.

What should a software handover checklist include?

Copy the table and assign an owner and a date to each row. The receiver, not the giver, ticks each item after testing it. A line the giver ticks alone is a claim, not a result.

Software handover checklist
AreaWhat to hand overHow the receiver verifies
Source codeAll repositories, branches, tags, and full history, including private dependencies and submodulesClone fresh and build from scratch
Hosting and cloudAccounts, projects, infrastructure definitions, and environments owned by your organizationLog in as an owner and list resources
Domains and DNSRegistrar and DNS control under your organizationConfirm you can edit records
App store and third-party accountsDeveloper accounts, payment, email, analytics, and AI provider accountsCheck the owner of each is your organization
Secrets and credentialsA full list, stored in a secrets manager you controlRotate each and confirm the app still runs
DeploymentThe pipeline, environment settings, and release stepsDeploy to staging yourself
Data and backupsDatabase access, backup schedule, and restore stepsRestore a backup to a test copy
DocumentationArchitecture overview, setup guide, runbooks, API docs, decisions logFollow the setup guide without help
Tests and qualityTest suites, how to run them, and resultsRun them and read the output
Monitoring and alertsDashboards, alert rules, and who is notifiedTrigger a test alert
Known issues and open workA written list with severity and contextReview in the walkthrough
Licenses and ownershipThird-party and open-source components, and IP termsMatch against the contract

How do you run the handover, step by step?

  1. Agree the scope, the date, and a named lead on each side. Output: a handover plan with owners.
  2. Move repositories into accounts your organization controls. Output: code with full history under your ownership.
  3. Transfer hosting, domains, store, and third-party accounts to organization identities. Output: accounts not tied to any individual's email.
  4. List every secret and credential, move them into a secrets manager, then rotate them. Output: old copies stop working.
  5. Hand over documentation, runbooks, and the known-issues list. Output: written knowledge in a shared place.
  6. Have the receiver deploy from scratch using only the handed-over material. Output: proof the setup guide works.
  7. Have the receiver run a rollback and a backup restore. Output: proof of recovery.
  8. Hold a walkthrough covering architecture, quirks, and open work. Output: recorded knowledge transfer.
  9. Sign off and keep a short support window for questions. Output: a closed handover and a defined tail.

Rehearse the handover before the deadline if you can. A dry run shows which accounts, documents, and credentials are missing while there is still time to fix them.

What does it mean to own the code and accounts?

Ownership has a legal side and a practical side. The contract should say who owns the code, designs, and data. In practice you own it only if it sits in accounts you control. Code in a vendor's private account, or a copy with no history, leaves you dependent on them even if the contract says otherwise.

Ownership red flags and fixes
Red flagWhy it mattersFix
Code only in the vendor's repositoryYou cannot continue without themMove to your organization's repositories with history
Accounts created with an engineer's personal emailAccess disappears when the person leavesTransfer to organization or shared role addresses
Production credentials shared in chat or documentsSecrets leak and spreadRotate and store in a secrets manager
Domain registered in the vendor's nameYou can lose your own addressTransfer the registration to you
Unlicensed or unclear third-party componentsLegal and security exposureDocument licenses and replace what is unclear
Only the builder knows how to deployA single point of failureDocument and rehearse deployment

Put ownership terms in the contract before work starts, and keep code and accounts in your own organization from day one. Then the final handover is small. The vendor due diligence checklist lists the contract questions to ask up front.

How do you hand over credentials safely?

Credentials are where handovers quietly break. Keys and passwords are scattered across code, chat, laptops, and dashboards. Gather them into a list, store them in a managed secrets store that the receiver controls, and then rotate them. Rotation is what makes the handover safe, because it removes the access the old team still holds.

  • Inventory every secret: database, cloud, payment, email, AI provider, analytics, signing keys, and webhooks.
  • Do not send secrets by email or chat. Use the secrets manager or a password manager with shared vaults.
  • Rotate each secret after transfer and confirm the application works with the new value.
  • Remove accounts and keys belonging to the previous team, including service accounts and tokens.
  • Review who has production access, and keep only people who need it.
  • Check that no secrets sit in the repository history. If any do, rotate them.

At StackLift, agents work on feature branches and never touch production secrets, which keeps the secret list small and the handover simpler.

What documentation and knowledge transfer do you need?

Documentation should let a competent engineer who has never seen the system set it up, deploy it, and fix common problems. Written material survives staff changes, and a recorded walkthrough captures the reasons behind decisions that code does not show.

Handover documents
DocumentContentsReader
Architecture overviewComponents, data flow, third-party services, and diagramsEngineers, new vendor
Setup guideHow to run the system locally and in each environmentEngineers
Deployment and rollback runbookRelease steps, checks, and how to undo a releaseEngineers, operations
Operations runbookCommon failures, alerts, backup and restore, on-call contactsOperations
API documentationEndpoints, authentication, and examplesIntegrators
Decision logKey choices and why they were madeEngineers, owners
Known issues and technical debtOpen bugs, shortcuts, and risks; see technical debtProduct owner, engineers
User and admin guidesHow the product is used and managedStaff and support

Record the walkthrough sessions and store them with the documents. For deployment and recovery details, the production readiness checklist lists what a runbook should cover.

How do you verify the handover and sign off?

Verification turns the checklist from a promise into evidence. The strongest test is a fresh deploy and a rollback by the receiving team, using only what was handed over. If the receiver gets stuck, that gap is a missing document or credential, and you have found it while the giver can still help.

Verification tests
TestPass condition
Fresh clone and buildThe receiver builds the system from the repositories alone
Deploy to stagingA release goes out using the documented steps
RollbackThe previous version can be restored by the receiver
Backup restoreData is restored to a test copy and checked
Credential rotationThe system runs on new secrets, and old ones fail
Account ownership checkEvery account lists your organization as owner
Walkthrough questionsThe receiver can answer the common what-if questions

Sign off with a record of what was handed over, what was verified, and what remains open. Keep a support window for questions, and set an end date for it. After acceptance, run the user acceptance testing plan if the handover includes a release, and read the legacy modernization roadmap if you are taking over an older system.

What if you are taking over software without help from the previous team?

Sometimes the previous team is gone or not cooperative. Secure ownership first: get control of the repositories, hosting, domains, and accounts, even if that means working with the registrar or provider. Then audit the code and the system before you change anything.

  • Gain control of code, hosting, and domains, and rotate every secret you can find.
  • Inventory what runs in production and what it depends on.
  • Check backups and restore one before you trust them.
  • Read the code for obvious security gaps and missing tests, especially if it was built quickly or with AI tools.
  • Write the missing runbooks as you learn the system.
  • Plan the first changes small, and add tests around the areas you touch.

StackLift's Production Rescue Sprint audits and hardens AI-coded prototypes; see vibe-coded app rescue. For other takeovers, run the free estimate or contact us to scope an audit.

Questions people ask

What should be included in a software handover?

Source code with full history, hosting and account ownership, rotated secrets, deployment and operations runbooks, architecture and API documentation, tests, monitoring details, and a list of known issues and open work.

Who should own the code after a vendor builds it?

You should, as stated in the contract, and in practice by keeping the code in repositories your organization controls from the start. Ownership that depends on the vendor's account is fragile.

Why rotate credentials during a handover?

The previous team may still hold copies of keys and passwords. Rotating them after transfer makes sure only the new owners have access, and shows that the system runs on credentials you control.

How do you test that a handover worked?

Have the receiving team build from a fresh clone, deploy to staging, roll back, restore a backup, and run on rotated credentials, using only the handed-over material. Gaps show up as missing steps or documents.

How long should the support window after handover last?

Long enough for the receiving team to meet a full cycle of normal work, such as one release and one month-end if the system has them. Agree an end date so the tail does not become permanent.

What documentation matters most?

The setup guide, the deployment and rollback runbook, and the operations runbook. They let a new engineer run and fix the system. An architecture overview and decision log come next.

What if the previous vendor will not cooperate?

Secure access first through the registrar, hosting provider, and any account you can legally control. Then audit, rotate secrets, and document as you learn. Take legal advice if ownership is disputed.

Sources

Sources and further reading

The standards, rules, research and official documentation this page draws on.