Agentic Data & Software Engineering

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

A thin red cord running along the floor of a corridor in a hedge maze and disappearing into the distance, in the fog.
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

  1. Ask for the list of what «must not be touched» before the handover.
  2. Read the system read-only and document what is there.
  3. Write the project kick-off and have it validated by someone who knows the project.
  4. Put evolution work in a single queue, with contract and validation.
  5. 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.

Frequently asked questions

What is application maintenance?

It is the work of continuing to improve and adapt an application in production: new features, business changes and adjustments, as well as bug fixes.

How do you inherit a live project without risk?

By understanding it first in read-only mode, writing down its rules and decisions in a system of your own, and putting the ongoing evolution work in a queue with criteria and validation.

Do you have to stop evolution work during a change of supplier?

No. Requests keep entering the same queue, each with its own contract, its tests and its validation.

Does inheriting a project mean you have to migrate it?

No. You first understand and document it; then, with data, you decide whether to maintain, modernise or migrate.

Keep reading