Start typing to search this publication.
techcirkle
Open menu

Subscribe to techcirkle

Get new posts delivered straight to your inbox.

The Handover Test: Can You Actually Leave Your Development Agency?

Whether you can leave a development agency cheaply is decided in week one by architecture and contract, not at the end. Here is the concrete test.

techcirkle
5 min read
Cover image for The Handover Test: Can You Actually Leave Your Development Agency?
Developers reviewing project architecture together
Developers reviewing project architecture together

Here is a question worth asking about your development agency, ideally before you have one: if you hired two engineers tomorrow and halved the agency's allocation, how long until those engineers were productive?

If the honest answer is four months, you do not have a codebase. You have a subscription.

The cost of leaving is not determined at the end of an engagement. It is determined in the first fortnight, by a small number of architectural and contractual decisions that are cheap to get right and nearly impossible to retrofit. This is the test.

Test 1: Clone and run

The single most informative exercise. Take the repository, hand it to an engineer who has never seen it, and time how long until they have it running locally with a working database and can make a visible change.

Under an hour with only the README: excellent. Half a day with a couple of questions: acceptable. Two days and three Slack threads: you have a problem. Impossible without a specific person: you have a serious problem.

The reason this test works is that it is a proxy for everything else. Environment reproducibility correlates almost perfectly with documentation quality, dependency hygiene, and whether the team has ever onboarded anyone.

Test 2: Find the reasoning

Pick the three decisions in the system that would be most expensive to reverse. Usually: the data model for the core entity, the authentication and authorisation approach, and the hosting and deployment topology.

Now find the written reasoning for each. Not the implementation — the why. What alternatives were considered, what constraints drove the choice, and under what conditions it should be revisited.

If that writing does not exist, every future engineer will either preserve a decision nobody can justify or relitigate it from scratch. Both are expensive. Architecture decision records are twenty minutes each to write at the time and effectively impossible to reconstruct a year later.

Test 3: Follow the accounts

Walk the list and check whose name is on each one.

  • Source repository organisation

  • Cloud provider account and billing

  • Domain registrar and DNS

  • App store developer accounts

  • Payment provider

  • Error tracking, analytics, email delivery

  • Secrets store

Every one of these in the vendor's name is a point of leverage during any disagreement and a migration project during any transition. The app store accounts are the worst offender, because transferring a published mobile app between developer accounts is genuinely painful and is usually discovered at the moment you least want a two-week detour.

This is pure contract hygiene. It costs nothing on day one.

Test 4: Read the commit history

Open the repository history and look at the distribution.

One author writing ninety percent of everything means one person holds the model of the system, and their departure is an event. A healthy distribution across three or four contributors means the knowledge is at least partly shared.

Also check commit granularity. Commits the size of a whole feature with messages like updates tell you nobody expects to read this history. Commits scoped to a single change with a message that explains intent tell you the team writes for a future reader — who might be you.

Test 5: Break something on purpose

In a staging environment, with permission, break something small. Point the database at a bad credential. Delete a required environment variable.

What you want to observe: does the failure surface as a clear error somewhere a human will see it, or does it fail silently and get discovered by a customer? Structured logging and error tracking are the cheapest infrastructure in software and the most commonly skipped when someone is optimising a proposal down to win a bid.

Test 6: Check the tests where the money is

Total coverage percentage is a weak signal. Coverage on specific paths is a strong one.

Look at the paths that handle payment, authentication, permission checks, and personal data. These are where a subtle error is expensive rather than annoying, and — relevant in 2026 — they are exactly the kind of logic where generated code produces a plausible-looking implementation that is wrong in one branch.

If those paths are untested, your ability to change anything near them safely is close to zero, which means the next team will route around them, which is how systems calcify.

What this costs to get right

Almost nothing, if it is agreed at the start. A documented local setup is an afternoon. Architecture decision records are twenty minutes each. Account ownership is a clause. Error tracking is an hour. Tests on money paths are ordinary engineering.

Retrofitting all of it after eighteen months is a project — usually a quarter of engineering time that produces no user-visible value, which means it competes with the roadmap and loses, which means it does not happen.

So put it in the contract. A handover document as a named deliverable with acceptance criteria. Repositories under your organisation from day one. Accounts in your name. And a partner who understands why you are asking will not be offended, because the good ones assume you will eventually hire in-house and write accordingly.

The full buyer's guide — engagement models, AI cost structure, pricing bands and a comparison scorecard — is here: How to Choose a Software Development Company for Startups in 2026. See also our overview of custom software development for where each delivery model fits.

Frequently Asked Questions

How do I tell if my codebase is portable to a new team?

Hand the repository to an engineer who has never seen it and time how long until they can run it locally and make a visible change. Under an hour with only the README is excellent; two days with multiple conversations indicates real portability debt.

What are architecture decision records and why do they matter?

Short documents recording a decision, the alternatives considered, the constraints that drove it, and the conditions under which it should be revisited. They cost about twenty minutes each to write and cannot realistically be reconstructed a year later.

Which accounts should be in my company's name?

All of them — repository organisation, cloud and billing, domain and DNS, app store developer accounts, payment provider, error tracking and analytics, and the secrets store. App store accounts in particular are painful to transfer after a mobile app is published.

What should I look for in commit history?

Author distribution and commit granularity. A single author writing most of the code concentrates system knowledge in one person. Large commits with uninformative messages indicate nobody expects the history to be read.

Which code paths most need test coverage?

Payment, authentication, permission checks and personal data handling. These are where subtle errors are expensive rather than annoying, and where plausible-looking generated implementations most often fail in a single unexercised branch.

Subscribe to techcirkle