FDE Times dataFDE jobs open 873▼9 Change in open roles over 7 days, like-for-like: roles from companies we started tracking this week are left outNew in 7 days 55Companies hiring 181Remote-friendly 25%Median US pay $200kTop hirer Databricks 98
中文VI

The newspaper of the Forward Deployed Engineer

Guides

Inheriting an abandoned project? Leave the code alone for a week

An ownership inventory, a production baseline and a written assessment, not instinct, should decide what genuinely needs to be rebuilt.

ShareLinkedInFacebookX

In brief

  • The first goal is to keep the business running as usual, not to improve anything yet.
  • Read the real system before the documentation: when the two disagree, the database is right.
  • A full rewrite is a conclusion drawn from evidence; most inherited code only needs refactoring.
Single-level decision tree: the question "Is the architecture sound?". The "Yes" branch, highlighted in orange, leads to a Refactor box, where most decisions end. The grey "No" branch leads to "Rebuild that part", for example a component that writes straight to the database with no queue.
In the first week of a takeover, assess each component in turn: if the architecture is sound, refactor; only if it is flawed, rebuild that part. Source: Redwerk, Wavect, based on the article.

On Monday you arrive at the client’s office. The previous contractor has gone, leaving behind a repo, a few cloud accounts whose passwords nobody seems to hold, a pipeline that half works, and a leadership team asking “when will it be done?”. The question everyone wants answered first is whether to tear it all down and start again.

That is the wrong place to start. A piece on scoping in AI Codex observes that most forward-deployed engagements that go off course have already done so by the end of the first week. On a takeover, that first week carries even more weight: you inherit not only the system but also whatever doubts the client still has after a partnership that ended halfway.

What follows walks through the first five days: taking stock of what exists, then settling the list of things to rebuild in a way you can defend to the client with numbers.

The first job is not fixing

Thoughtworks, describing a takeover of a large legacy system, set a deliberately modest immediate goal: at the very least, keep the business running as usual. No improvements, no optimisation. Just do not break what is already running.

It sounds obvious, but the pressure on site pulls the other way. The client wants to see progress, and the quickest way to “show progress” is to commit code. The trouble is that every change made before you understand the system is a gamble, and if it goes wrong, the fault is recorded against your name, not the previous contractor’s.

So the first week has three deliverables: an ownership inventory, a production baseline and a written assessment. The rebuild list comes out of those three.

Who really holds the keys?

Wavect’s 30-day takeover plan requires that, on days 1 to 5, you record for every asset: the legal owner of the account, who pays, the admins, the recovery contact and the handover path.

Assets here means everything: domains, cloud accounts, repos, third-party API keys, email-sending accounts, even the workspace of the task-tracking tool.

Picture a logistics client with an order-sorting system the previous contractor left half-built. After day two, the inventory might look like this:

Asset Legal owner Payer Admin Recovery Handover
Main domain Client Client Previous contractor Contractor’s email Change admin via registrar
Cloud account Previous contractor Previous contractor, rebilled Previous contractor Unknown Transfer account or rebuild
Repo Client’s organisation Client Two contractor devs Client Remove access, add new team
LLM service API key Unknown Contractor’s card Unknown Unknown Needs verifying

Every “unknown” cell is a specific risk you can now name. The two middle rows in this example are more dangerous than any bad code: if the contractor stops paying for the cloud account, the system shuts down and nobody at the client has the rights to switch it back on.

When you start rotating passwords and access keys, Wavect flags an easily missed point: rollback rights must sit with the client. Do not become the next previous contractor, the only person holding the keys.

Measure first, then change

The second deliverable is the baseline. Wavect lists what to record before any change: traffic, error rate, latency, queue depth, backup status, open incidents, support ticket volume and the status of known releases.

The point is to be able, later on, to tell the faults you caused from the ones you inherited. Suppose the order-sorting system is failing 4% of requests.

Without a measurement, you deploy your first patch on Thursday, the client sees 4% errors the following week and asks why you broke it. With a timestamped baseline, you point at the number and say: the system was already at this level, and here is the plan to bring it down.

The baseline is also the foundation for every later conversation about value. Without a starting point, nobody can prove how much things have improved.

Trust the database, not the documentation

Previous contractors usually leave documentation, and the documentation is usually prettier than reality. AI Codex advises asking for read access to the real system before asking for the documents, because documentation describes intent while the database describes reality, and when the two disagree, the database is right.

In the logistics example, the documentation might say every order is sorted automatically. A query counting orders by status might show that a large share of them are sitting in a state awaiting manual review. That gap is exactly what the client is paying to fix, and it appears on no page of the documentation.

A guide on dev.to to taking over a codebase from an agency suggests spending the first 48 hours just reading. In that window, read the code, the logs, the commit history and the schema before touching anything.

To keep the big picture in view, Thoughtworks drew the inherited architecture as C1/C2 diagrams and tracked takeover progress on a map, with green markers for services that were done and grey for those still waiting.

A map like that is also the best reporting tool you can hand the client every Friday afternoon.

Settle the rebuild list with a criterion, not a feeling

By day four you have enough data to classify each component. Wavect writes that “rewrite everything” is a conclusion, not a starting method.

Redwerk offers a tighter rule: refactor when the architecture is sound and the mess is in the details, and most decisions about inherited code end in refactoring because messy code is far more common than genuinely broken code.

Applied to the example: if the data flow from the order system to the sorter points the right way but the code is repetitive and lacks tests, that is a refactor.

If the sorter writes straight into the production database with no queue, so that every failure loses orders, that is an architectural problem and there is a case for rebuilding that part.

Two different verdicts for two components, not a single “tear it down” for the whole system.

Thoughtworks used a standard template as the acceptance criteria for taking over each service. You can do the same: a service only turns “green” once the owner of every asset is known, it has a baseline, someone on the new team can deploy and roll it back, and it has been placed in one of three groups: keep, refactor or rebuild.

The written assessment and who signs it

The dev.to guide is emphatic: before changing anything, write a document. The day-five assessment contains the inventory, the baseline, the service map and the classification list with the reasoning for each item.

But a document is not enough if it reaches the wrong reader. AI Codex advises pushing until there is a measurable definition of success that the person who controls the budget has agreed to.

In the logistics example, that might be “the share of orders requiring manual review falls to X within Y weeks”, with X and Y set by the client on the basis of the baseline you have just measured.

Once the budget holder signs off, the rebuild list is no longer your personal opinion but a shared commitment.

Common mistakes

The most common mistake is fixing things on day one to “score points”, then being unable to show how bad the system was beforehand. Next comes trusting the handover documentation without opening the database.

Another frequent one is rotating every credential but keeping admin rights to yourself, repeating exactly the problem you were hired to solve. And finally, settling scope with the friendliest user rather than the person holding the budget.

Takeover skills belong on your CV

When reading FDE job postings, look for lines that mention working on a client’s existing systems: that is where takeover skills will be used, and where a concrete example on your CV is worth including.

This week’s exercise: pick a system you look after but did not build, assume its contractor vanishes tomorrow morning, and write a one-page assessment in an afternoon. The number of “unknown” cells you count is the risk your client is carrying without knowing it.

Was this article useful?

Use with your AI assistantAsk Claude ↗Ask ChatGPT ↗
6 sources
Read next on the roadmap · Stage 4: CustomersThe 45 minutes that show who can quietly kill your AI projectA RACI matrix and a power/interest map show who approves the work, who will use it and who can block it before a line of code is written.