Skip to content
Trellis
Blog
Engineering6 min read

The five checks we run before touching someone else's production app

Taking over a codebase you did not write is mostly an exercise in finding out what will bite you first. These are the five things we establish before we change a line of it.

Trellis Studio27 October 2026

Every takeover starts the same way: the app works, nobody is quite sure why, and the person who built it is busy on something else. Before we touch anything, we answer five questions. Each one is cheap to answer in week one and expensive to discover during an incident.

1. Can we reproduce a deploy from a clean checkout?

We clone the repository into an empty directory, follow the README exactly, and deploy to a staging environment. If that fails, we stop and fix the deploy path before writing a feature. Working software that only one laptop can build is a single point of failure with a salary.

Two things make this fail more often than anything else: a build step that depends on files excluded from the repo, and environment variables that exist only in a hosting dashboard. Both are fixable in an afternoon, and both are invisible until you try.

The usual outcome is a small commit that adds a .env.example, a documented build command, and a container image or build script that CI can run. That commit is the foundation for everything after it.

  • Clone into a fresh directory and follow only the documentation.
  • Deploy that checkout to a throwaway environment.
  • Confirm a rollback works, not just a deploy.

2. What actually happens when the database is lost?

We ask for the restore procedure and then we run it, against a scratch instance, with the person who owns the data watching. A backup schedule is a schedule; a restore is evidence.

What to checkWhy it mattersTypical gap
Last successful restoreProves the dumps are readableNever tested
Point-in-time windowSets how much data you can loseUnknown
Restore timeSets your realistic downtimeMeasured once, years ago

If the restore takes four hours, that is not a backup problem, it is a product decision about what downtime is acceptable. It is worth naming out loud rather than discovering during a bad night.

3. Which secrets are real, and where do they live?

Old projects accumulate credentials in places nobody remembers: CI variables, a config file in a private bucket, a former contractor's environment. We inventory them, confirm which are still live, and rotate anything whose history is unclear.

This is also the point at which we look for secrets committed to git history. Removing them from the current commit does not help; the value has to be revoked. See the AWS guidance on rotating access keys for the mechanics on that side.

  • List every place a credential is stored, including CI and hosting dashboards.
  • Revoke anything you cannot prove is used.
  • Move what remains into one secret store with an audit trail.

4. What tells you the app is broken, and who hears it?

We look for three things: an uptime check on the user-facing path, error reporting that is actually wired to an inbox someone reads, and one dashboard that answers whether the app is healthy. Plenty of teams have all three and still find out about outages from customers, because the alert goes to a channel nobody watches.

The fix is usually organisational rather than technical: name the person on call, name the escalation path, and send the alert where that person actually looks.

5. Who knows why it is built this way?

There is always one decision that looks strange until someone explains it, and the explanation usually lives in one person's memory. We write those down while we still have access to them, because the alternative is re-learning them by breaking things.

A short architecture note that answers what talks to what, which parts are load-bearing, and what has been tried and abandoned is worth more in the first month than any amount of code review.

What this buys you

None of the five checks add a feature. What they add is the ability to change the system without gambling, which is the whole job. In practice the first week of a takeover produces a handful of small commits: a reproducible build, a tested restore, a rotated secret, an alert that reaches a human, and a page of notes.

After that, the work looks like normal engineering, because the surprises have been spent early and deliberately.

Keep reading

More from the blog

Tell us what you are building.

A free 30-minute call, no slide deck and no obligation. If we are not the right fit, we will tell you who is.