Application maintenance: inheriting a live project without losing the thread
By Xavier Franco, CEO de Elternativa · Grupo Zemsania
· 5 min read
Written with the help of AI and reviewed by Xavier Franco

In this article
There is a moment that almost every technology leader has lived through or will live through: inheriting a live project. You change supplier, the team that ran it leaves or the department is reorganised, and suddenly you have a system in production, with users, with pending requests and with application maintenance that cannot be stopped. It is like jumping onto a moving train: you can’t stop it to understand it. And yet you have to understand it.
Why it is so scary
Inheriting a system that works has a catch: the system works, but nobody has given you the manual. What you really need to know is usually scattered between the code, the departing team’s heads and a handful of documents of uncertain date.
And then there is the technical debt that comes with it. The 2024 Stack Overflow survey says that technical debt is the biggest frustration at work for 63% of professional developers. When you inherit a project, you inherit its debt too.
In practice: before signing a change of supplier, ask for a list of the five things in the system that «must not be touched». If nobody can write it, the risk is greater than it looks.
What gets lost in the handover
In a badly done handover, three things get lost, and you almost never see it until you need them:
- The why behind decisions. Why it was done this way and not another. Without that, the new team argues again over what was already decided or, worse, undoes something that had its reason.
- The unwritten rules. How it is deployed, what is tested, which conventions the code follows.
- What has already failed. The mistakes the previous team learned to avoid and the new one is about to repeat.
A two-hour handover meeting and a document don’t cover this. No matter how hard you try.
First, understand without touching
The first step is to understand the system from what is there, not from what you are told. That means reading the repository, the configuration and the deployment processes, and working out from them how it really works.
With AI, this reading is much faster than a few years ago. But it has to be done read-only and with method: everything that gets documented, linked to where it comes from. And if the system is old and has no documentation, the functional and technical documentation comes from the code itself, not from anyone’s memory.
In practice: for the first few weeks, ban structural changes. Have the new team first deliver the documentation of what exists, validated by someone who knows it.
Then, write the kick-off
Next comes writing what in our method we call the project kick-off: how the team works, which branches there are, which environments, how things are tested and which conventions are followed. It is told in conversation and ends up written in the system, not in a document that expires.
If the departing team is still available for a few weeks, this is the best moment for them to validate it. What they say is written down and linked to the project.
Without stopping evolution work
Meanwhile, the business keeps asking for things. And here is the key: evolution work does not stop. Requests go into the same queue, each with its contract and its acceptance criteria set before starting. AI instances develop them, a different one tests them and a person on the team validates each closure.
What is learned in each task is written down as a rule. That way, within a few weeks, the system knows more about the project than any handover document.
In practice: measure how long the new team takes to close the first requests and how that evolves week by week. It is the best sign of whether the handover is going well.
And technical debt, finally in the plan
There is an effect I really like. When a team inherits a project, it usually spends all its time making sure it doesn’t break. Technical debt is left for «when there is time», which never comes.
With orchestrated capacity, that changes: several instances working in parallel mean that what didn’t fit gets into the plan, such as technical debt, legacy or pending migrations. It is not just the speed that changes: it is the scope.
Inheriting is not migrating
One last nuance. Inheriting a project does not oblige you to migrate it. Often the new team’s temptation is to redo everything «its own way». My advice is the opposite: first understand it, then decide. With the documentation extracted from the code and the evolution work under way, you will have data to know whether to modernise, migrate or simply maintain better.
Where to start
- Ask for the list of what «must not be touched» before the handover.
- Read the system read-only and document what is there.
- Write the project kick-off and have it validated by someone who knows the project.
- Put evolution work in a single queue, with contract and validation.
- Decide with data whether to maintain, modernise or migrate.
How we help
At Agentic Data & Software Engineering we orchestrate the development AIs you already have across the whole SDLC, including evolution work and support: in the same queue, with what has been learned written down as rules. We deliver it in the arrangement you already buy: technical assistance, fixed-scope project or managed service.
We do it with Agentagile: the kick-off, the plan, each task and its validation stay in the system, and the project knowledge in a database you own. The team changes; the method stays.
What would happen if you changed supplier tomorrow?
In a demo, we show you how to take over a live project: plan, rules and knowledge in a system of your own from day one.


