Skip to content

Delivering a platform, then delivering the people who will run it

On a national addressing program the condition was not negotiable: code and hosting in the institution's name, a local project manager and two developers trained on the project. What that changes about how you build.

By Laurent TulpanPublished 9 min read

The program concerned digital addressing at national scale, and the urban platform that had to sit on top of it. No off-the-shelf product did that.

The constraint set by the institution was not negotiable, and it determined everything that followed: the source code, the credentials and the hosting had to be in the country’s name. Not a license to use. Not granted access. Ownership.

We built both systems, put the addressing base into production, and recruited and trained a Cameroonian project manager and two Cameroonian developers on the project. The sources were transferred.

What that constraint changes is less what you deliver than how you build it.

Building to be taken over is not the same as building well

People assume the difference is quality: clean code would be code somebody can pick up.

That is not true. Code can be excellent and completely opaque to somebody who was not in the room when the decisions were made. What is missing is not quality, it is context.

Three things change when you know from day one that somebody else will take over.

You write down why, not only what. A comment describing what a function does is useless, since the code already says it. A comment explaining why a special case exists, which constraint imposed it and what would break if it were removed, saves a week of investigation for whoever inherits it.

You refuse the clever solution. There is always an elegant, compact way to do something, which its author finds obvious and nobody else reads without effort. On a system meant to be handed over, elegance that needs explaining is a deferred cost.

You choose ordinary tools. The technically best-suited technology is the wrong one if the team taking over will not find it in the people around them. That criterion ruled out several technically superior choices, and it was the right call each time.

Training on a live project, with its real constraints

The project manager and the two developers did not take a course and then join the project. They were recruited onto the project and came up to speed on it.

That is slower. It has to be said honestly, and above all said when the work is being priced rather than when the schedule slips. A code review that takes twenty minutes takes an hour when it also has to explain. An architecture decision that takes ten minutes between two people who understand each other takes half a day when it has to be understood by somebody encountering it for the first time.

That time is not recovered later. It is moved. It is no longer spent on remote support, on repeating explanations, on emergency interventions into a system nobody on site can diagnose.

What works, and what no documentation replaces: put the person in a position to break something, in an environment where it does not matter. You do not learn a system by reading it. You learn it by repairing it.

What makes a handover real rather than contractual

The transfer of sources is the moment many projects reveal it was never prepared.

Three checks, done before the end of the engagement rather than on the last day.

Somebody else deploys, for real. Not the vendor demonstrating how: the person who will take over, alone, following the documentation. Everything missing surfaces within the hour, and there is always something missing, usually a configuration value nobody wrote down because it lived in the head of whoever set it.

The credentials are in the right name. Hosting taken out by the vendor, even with the best intentions, is a dependency that only reveals itself at the point it becomes a problem. The name on the contract matters as much as the name on the repository.

A failure is simulated. The system is deliberately stopped, and the local team restarts it. That is the only proof that the handover happened.

That last check is the one most often skipped, because it falls at a moment when everybody wants to close. Which is exactly why it has to be scheduled at the start rather than proposed at the end, in the same way that acceptance criteria only work when written before the build.

On availability, and what it owes to simplicity

The platform held for the whole duration of the program without interruption.

That is not an architectural feat, and presenting it as one would be dishonest. It owes a great deal to the fact that the system is simple: few components, few external dependencies, nothing that is not serving a purpose.

That lesson holds outside this context. A system meant to be operated by a team that did not build it must have few moving parts. Every additional component adds a failure mode and one more thing to understand, and on an inherited system both are paid twice.

What this project changed for us

The sovereignty constraint was not ours. It was imposed on us, and it made us better.

We began delivering the same way where nobody asked. Sources transferred, credentials in the client’s name, operating documentation, and one person trained internally. Not out of generosity: because a client who can leave is a client who stays for good reasons, and because a system designed to be handed over is simpler, better documented and more robust, including when nobody ever takes it over.

It is also why we treat the exit clause as something to settle at signature rather than at departure, and the only commercial promise we make whose execution a client can verify.

Further reading

The questions this raises, answered straight.

Does training the client's team mean giving up the maintenance revenue?

If the business model depends on the client being unable to do without you, yes. Ours depends on fixed fees and on the value of what is delivered, so no.

In practice a client able to operate what we built comes back more often, because they come back for value rather than because they have no choice. Dependency that is endured produces resentment, not loyalty.

Can you really train somebody on a live project without slowing it down?

The project is slowed, mechanically, and that belongs in the estimate rather than in a later surprise.

What is false is the idea that you make the time back afterwards: you do not make it back, you move it. Time invested during the build is time not spent later on remote support, repeated explanations and emergency interventions on a system nobody on site understands.

What does owning the code actually mean?

Three things together, and two are not enough:

  • The source code itself, in a repository the client controls.
  • The credentials to hosting, in their name rather than ours.
  • Up-to-date operating documentation explaining how the system deploys and restarts.

A transfer clause without those three actually delivered has never restarted anything.

Does this apply to a small company as well?

It is the same thing. A company without a technical team is in the position of an institution that does not want to depend on a distant vendor: it needs at least one person internally able to change the business rules without calling.

You do not train three people, you train one owner, and the objective is identical.

It is the most profitable part of our engagements and the part most often cut from a quote.

Recognize your situation? 20 minutes is enough to tell.

Describe what is happening on your side, and where your data and customers are. You get a plain answer on whether we can help, and a better route if there is one.