Ownership and continuity
Ownership and continuity, in short
What a company owns when a project ends, who can run the system afterwards, and how it keeps changing once the first release is behind it.
A system we build does not need us in order to keep running. The code, the infrastructure that creates it, the documentation and the automated tests stay with the company. So does the knowledge needed to change them.
What stays at the end
The source code sits in repositories the company owns, with its history. The infrastructure is written as code, so an environment can be rebuilt instead of remembered. Architecture decisions, operating procedures and automated tests are part of the delivery, not an extra. Automated tests carry the most weight here. They record the behaviour that was agreed, so the next team changes the system and still sees when it breaks.
Handover is work, not an email
A handover works when the people taking the system over can run it without calling anyone. It is planned, and it has its own deliverables.
Named people on both sides
Every part of the system gets a named owner on each side. The people leaving the project stay reachable for an agreed period, so later questions still find someone.
Environments, accounts and licences
Each environment, administrative account and licence is listed and transferred. Nothing stays in a personal login, and nothing depends on a password one person remembers.
The in-house team works the system first
Before the handover the in-house team runs releases and incidents alongside the people who built the system. The written procedures they follow include recovery from a failure.
Autonomy shows in the first release
Independence is not a clause in a contract. It shows when a team that has never built this kind of system delivers on its own. On one platform, four developers with no front-end experience shipped the first release themselves. They worked on foundations delivered with the stack decisions written down and the infrastructure in a repository their company owns. A team becomes autonomous by doing the work while the people who built the system are still there.
A system that keeps changing
After the first release the work continues as versions, and the company decides what goes into each one. The same work bought as a service is set out on Operations and evolution.
Named versions, a readable history
Every change belongs to a named release with its tickets attached. Years later the history still reads as a sequence of decisions, not as a pile of commits.
Monitoring that makes the system readable
Response times, errors and usage are measured from the browsers of the people using the system. A problem becomes visible while it is still small.
Technical debt the company can schedule
Each item of debt carries the risk it creates and the effort to clear it. It then competes for capacity in the same plan as new features.
Go deeper
- Operations and evolution
Work that gets bought again
Continuity is easier to claim than to show. One group platform has been put out to tender twice and won back twice. Another engagement is now in its third three-year renewal. The same holds for the products we own. Every luxury maison that adopted our visual merchandising platform still uses it, and has widened its use since. Keeping a product alive for paying customers sets the standard for everything else we run.
Contact us to validate the technical feasibility,
business impact and build your business case together.