← Back to the blogLegacy

You Just Inherited a System. Here Is What to Do Before You Touch It.

A takeover goes wrong when the first weeks go to patching. Four habits to know one module precisely and ship a first change you can stand behind.

November 4, 2026 · 5 min read

Maybe you joined as CTO, or a reorganization or an acquisition handed your team a platform built by people who have since left. The software runs, customers depend on it, and the honest answer to most questions about it is “we think so.”

The pressure in those first weeks is to start fixing things. Every quick patch shipped before you know the terrain is one more change nobody can explain later.

The goal is modest: within roughly ninety days, know one or two parts of the system precisely, have the business agree on what they should do, and ship a first change you can stand behind. Here are four habits that make that possible.

Spend the first two weeks on inventory

List every repository, including the forgotten ones: scripts, infrastructure, internal tools, the “temporary” service from four years ago. Confirm each one builds from a clean machine, and write down every step that wasn’t documented.

Locate the backups and test one restore. A backup nobody has restored is a hope, not a backup. Collect the scheduled jobs: cron entries, batch runs, queue consumers. They often carry business rules nobody remembers.

Then map who knows what. Reach the people who left while the door is still open. One hour with a former developer can save weeks.

Agree on a freeze with stakeholders: only urgent fixes ship, and each one is written down with its reason. You buy two calm weeks and a clean baseline.

Write rules as sentences a business owner can approve

Write each business rule as one sentence a non-engineer can read. “Orders over a set amount require a second approval” is a rule. A pasted if block is not. Could the person who owns this rule read it and say yes or no?

Rules hide in conditionals, but also in database constraints, stored procedures, form validation, configuration files, feature flags, batch jobs and the occasional hardcoded date.

Then tie each rule to where it lives. “A customer is refunded within 30 days” points to refund.py, the Payment API and the refunds table. With that link, a change to refund.py tells you which rules are at stake, and a change in refund policy tells you where to act.

Treat disagreements as a deliverable

Tickets, wiki pages, design files and people’s memories rarely agree with the code. In an illustrative case, a Jira ticket says the refund deadline is 14 days, the Confluence page says 30, and the code applies 21.

The code tells you what the system does today. It does not tell you what it was supposed to do. Whether 21 days is right is a business question.

So log each mismatch as a named gap, with every source, its value and its date. Assign it to the business owner who can settle it, and if there is no owner, you’ve found another problem worth flagging. And never fix a gap silently in the code. A quiet fix recreates exactly the knowledge loss you set out to repair.

A precise list changes the mood of a team. “We don’t know what this does” becomes twelve questions with owners, and twelve questions can be worked through.

Make the first change narrow and checked

Pick a pilot module with at least two of these traits: a change is on the roadmap, incidents keep coming back to it, other parts depend on its output, and it is small enough to understand in a few weeks.

You don’t need full test coverage. Put characterization tests where the module meets the rest of the world: given today’s input, assert today’s output, even if it looks odd. Cover each confirmed rule and each invariant.

Before the change, list the rules it touches, the ones it must leave alone, and the invariants that must still hold. Have the business owner approve the target rules, not the code diff. Afterwards, check each rule again, and watch for behavior nobody asked for. If AI writes part of the code, give it the approved rules and their sources, not just the ticket, then check what comes back against those rules one by one.

The full checklist

The Legacy use case shows how Lyriks carries this method once there are several modules and changes every week: a structured spec linked to the code and to every source, checked rule by rule. The full checklist runs 11 pages. It has tick-box lists for code, environments, written sources and people, a table of the decisions to bring to the business with who decides and what to bring, a 30/60/90-day plan with the outcomes you can show at each stage, and the common mistakes that stall a takeover, such as rewriting before understanding.

Go further

Guide · free · 11 pages

The legacy takeover checklist

What to inventory, recover and decide before you change code nobody understands anymore. Checklists you can tick, and a 30/60/90-day plan.

Keep your software in tune

Start with one module. Lyriks recovers its spec, then verifies every change. All it needs is your repository.