Modernize and Operate: Finding One Partner to Update Your Existing App Without a Rewrite

#update existing app without rewrite

Founder & Lead Developer

Expert in software development and legacy code optimization

LinkedIn

If your business runs on an application that still works but is getting older every month, you probably do not want a new system. You want someone to update your existing app without a rewrite, and then keep it running so you never end up in the same spot again. That is a specific kind of engagement, and it is harder to buy than it sounds, because most providers are set up to do either the project or the operations, rarely both.

Here is a short definition you can hold providers against:

A modernize and operate partner takes responsibility for an existing application as it is. They stabilise it, upgrade it in small steps while it stays in production, host and monitor it, and report to you every month on what changed and what is still at risk.

Why a rewrite is usually the wrong first move

A rewrite looks attractive on a whiteboard. In real projects it tends to take longer than planned, freezes feature work for months and loses business rules that were never written down anywhere except in the old code. We wrote about this tradeoff in more detail in when to rewrite vs refactor.

Most applications that are five to fifteen years old do not need to be thrown away. They need an upgraded runtime and framework, a cleanup of the parts that break most often, a deployment process someone other than the original developer understands, and hosting that is patched and watched. All of that can happen step by step while your team keeps using the system every day. Our plain language guide to legacy software modernization explains the general approach if you are new to the topic.

The catch is continuity. A modernization project that ends with a handover to nobody leaves you with a cleaner system that starts ageing again the next day. That is why it often makes sense to buy both halves from the same partner.

What a modernize and operate partner actually does

The work falls into four areas. They overlap in time, but it helps to name them separately when you compare offers.

Stabilise first

Before anything gets upgraded, the partner needs to know where the system is fragile. That means getting the code into a repository your company owns, setting up error tracking, writing down how a deployment works and fixing the two or three problems that currently cause the most support calls. A partner who skips this and starts with a framework upgrade is gambling with your production system.

Upgrade in small steps

The upgrades themselves should arrive as a series of small releases, each one shippable on its own. A typical sequence for a PHP application might be: get onto a supported PHP version, then move the framework one major version at a time, then replace abandoned libraries. For a JavaScript frontend it might mean moving page by page instead of all at once. The point is that you never have a six month branch that only one person understands. We describe this pattern in modernizing legacy software without a feature freeze.

Host and operate

Operating the application means someone is responsible for the servers or containers, backups that are actually tested by restoring them, TLS certificates, monitoring and the response when something goes down at 7 in the morning. If this part stays with a different company, or with an internal person who has three other jobs, the modernization work loses a lot of its value, because the partner cannot see what happens to their changes in production.

Report monthly

A short monthly report keeps you in control without forcing you to read code. It should list what was updated, what incidents occurred and how they were resolved, which dependencies are approaching end of life, and what the partner recommends for the next month. If you cannot get this in writing, you have no way to judge whether the money is well spent.

How to evaluate a partner who will update your existing app without a rewrite

Plenty of agencies will say yes to this kind of work. Fewer have done it repeatedly. Four topics separate the two groups quickly.

Ask about legacy work they have done

Ask for concrete examples of older systems they took over and upgraded while those systems stayed live. You want to hear about version jumps, data migrations and the problems they ran into, not about greenfield builds. If every reference is a new product built from scratch, that is a different skill set. Our article on what to look for in a legacy code refactoring partner has a longer list of questions.

Ask about update cadence

How often will dependencies be updated, and how is each update tested before it reaches production? A good answer names a frequency, mentions a staging environment and describes what happens when an update breaks something. A vague answer ("we keep things current") usually means updates happen when something forces them. The software maintenance retainer article goes through what this part of the contract should say.

Ask who is on call

Find out who gets the alert when the application goes down, how fast they respond, and whether that person knows the code. With a small partner the honest answer might be "the same two developers who work on it, during business hours, with a defined response time for critical issues outside them." That is fine if it is written down and matches what your business needs. What you want to avoid is an on call promise that is really a ticket queue nobody watches at night.

Ask about exit terms

This one feels awkward to raise early, but it matters most. If you end the contract, what do you get and how fast? At minimum: the full repository with history in an account you own, all credentials, infrastructure documentation, recent backups and a handover call. A partner who is confident in their work will agree to this without a fight. If a provider makes leaving slow or expensive, raise it before you sign, because it will be much harder to change later.

What the first 90 days should look like

Every system is different, but a reasonable first quarter usually follows a similar shape.

In the first month the partner gets access, moves the code into a repository you control, sets up monitoring and error tracking, and writes an assessment of the current state. That assessment should be readable by a non technical owner and should rank the risks by how likely and how expensive each one is. If the application has no automated tests at all, this is also when a few basic checks get added around the most important flows, so later upgrades have a safety net.

In the second month the first real upgrades ship. These are usually the ones with the clearest security value, such as moving off an unsupported runtime version, along with fixes for the issues that cause the most support load. Hosting may move to a new setup in this phase if the current one is unpatched or undocumented.

In the third month the regular rhythm starts: scheduled dependency updates, the first monthly report, and a roadmap for the larger upgrades that will take the next two or three quarters. By the end of day 90 you should be able to say where the code lives, who gets woken up if it breaks, and what the plan is for the next six months.

If after three months you still cannot answer those, something is off, and it is better to find out then than after a year.

Pricing models

There are three common ways to structure the cost.

A fixed monthly retainer covers operations, routine updates, monitoring and a set number of hours for improvements. It is predictable and works well once the system is stable. The risk is that larger upgrades get pushed back month after month because they never fit inside the hours.

A project plus retainer model prices the initial stabilisation and the big upgrades as a fixed or estimated project, then switches to a smaller monthly fee for operation. This makes the large one time effort visible and keeps the ongoing cost honest. It is often the clearest option for a first engagement.

Time and materials with a monthly cap gives the most flexibility and works when the scope is hard to estimate, for example when nobody knows how bad the code really is yet. You should insist on a cap and on a monthly report, otherwise costs drift.

Whichever model you choose, ask what is included and what triggers extra billing. Breaking changes caused by a routine update, security incidents and urgent weekend work are the usual grey areas. If you want a sense of the overall numbers, we wrote about what software maintenance costs per year.

Questions to ask in the first call

If you only have half an hour with a potential partner, these questions cover most of the ground:

  • Which older systems have you taken over and upgraded while they stayed in production?
  • What happens in the first two weeks after we sign?
  • How often do you update dependencies, and where do you test them?
  • Who responds if the application is down outside office hours?
  • What do we receive if we end the contract, and how long does that take?
  • What does your monthly report contain? Can we see an anonymised example?

How Wolf-Tech can help

We take over existing PHP, Symfony, React and Next.js applications, stabilise them, upgrade them in small releases and then host and operate them on a monthly basis. You keep ownership of the code and the infrastructure accounts at all times. You can read more about how we approach this on our legacy code optimization and custom software development pages.

If you have an application that works but worries you, send a short description of what it does, how old it is and who looks after it today to hello@wolf-tech.io, or visit wolf-tech.io. We will tell you honestly whether a step by step update makes sense or whether something else would serve you better.