Handover Without Lock-in: So Another Team Can Take Over

"What happens when you are no longer here?" That is one of the most honest questions a client can ask - and the answer should not be "we just stick around". A codebase another team can take over is the more robust codebase from day one.

What Lock-in Looks Like Up Close

Lock-in is rarely a single contract that binds you for ten years. Day-to-day lock-in is built from many small things that together make a switch expensive:

• Undocumented configuration. An env file with 40 variables, only half of which are explained anywhere.
• Half-automated deployments. A script that only runs on one laptop, because a tool was installed there two years ago.
• Implicit conventions. "We always name branches like this" - but no README explains why.
• Home-grown tools for standard problems. A custom logger, a custom HTTP client, a custom CSV library.

Each item is small. Together they turn a handover into a multi-week project.

Four Building Blocks of a Handover-Ready Codebase

Four things have the biggest effect - and are realistic in every project.

1. An onboarding script that actually runs. ./scripts/setup.sh from an empty laptop, and after ten minutes the application runs locally. If the script does not complete, that is a bug, not a comfort issue.
2. Architecture Decision Records. One file per relevant decision with context, alternatives considered, reasoning. No long wiki - 200 lines per ADR is enough. They answer the questions a new team asks in the first weeks.
3. Standard stack over home-grown. Before every custom solution: is there a popular OSS building block that does the job? Custom code is often technically elegant and handover-hostile.
4. A readable CI pipeline. If the pipeline consists of three clear phases (build, test, deploy), a new team can change it on first read. If it is 14 cross-referenced Forgejo workflows, it cannot.

Why This Is Not Decorative

These building blocks are not "documentation maintenance". They are engineering discipline that pays back immediately into ongoing work:

• Onboarding scripts keep the current team from stumbling - every new laptop, every container rebuild benefits.
• ADRs prevent discussions that restart every three months - "why are we using X again?".
• A standard stack reduces the amount of code your team has to maintain itself - every line of custom code is maintenance debt.
• Readable pipelines shorten error-analysis time - broken builds are not a mystery.

In other words: the investment pays off even if the handover never happens.

The Two-Week Field Test

An honest test takes two weeks and looks like this: a person who does not know the project gets the repository, the README, and nothing else. They are asked to ship a non-trivial feature. The places where they have to ask are the gaps in your onboarding material.

We do this regularly ourselves - and find two or three non-obvious gaps every time. That is the whole point: without a test there is no guarantee, with a test there is a list.

The External Trust Signal

Clients who have once been locked in spot the opposite quickly. "We deliver a handover that lets another team take over within two weeks" is a concrete promise you either keep or you do not. It is a far more credible trust signal than any certification.