We have no documentation for our software

It rarely means nobody knows anything. It means the knowledge is spread out: some in the code, some in the database, most of it with the three people who've used the system longest, and a bit on a printout by the despatch desk. The developer who could have written it down was busy building it, and then they left. That's how most of the bespoke systems we take over arrive.

Where it bites:

• You can't brief another developer, so every quote you get is a guess.
• A supplier proposes a full rewrite because they can't see inside the thing they'd be replacing.
• A new starter takes months to learn the system, and learns the workarounds along with it.
• Nobody changes anything, because nobody knows what else a change would touch.

Four sources, cross-checked against each other.

The code. Even without a comment in it, code says what it does. We read it and map the screens to the tables, and the tables to the processes. Where there's no source code at all, the compiled program and the database still tell most of the story.

The database. The schema is the most honest document a system has. Tables, relationships, the columns nobody uses any more, the one that changed meaning in 2014 and never got renamed.

The people. We sit with the people who use the system and watch the work go through it, and we ask about every workaround. The workarounds are where the undocumented rules live.

The paperwork around it. The spreadsheets, the printouts, the email templates, the link to Sage. Anything that goes in or comes out.

Then we write it down: what the system does, what depends on it and what it depends on. That document is section two of the assessment report, and the report is yours.

No. Helpful if you can, not required. An hour with them fills gaps faster, but most takeovers happen without the original developer, because they've usually retired, moved on or stopped answering. The code, the database and your team carry enough of the story between them.

Usually. It's a constraint, not a dead end. Sometimes the code can be recovered from the installed system or an old backup. Sometimes the right answer is to keep the running system supported while a replacement is built alongside it, sharing the same data, so nothing is lost while the new one takes over one process at a time. The assessment establishes which situation you're in before anyone spends money on either.

The legacy system assessment is from £395 + VAT, sized on a free one-hour consultation, with an exact price before you commit. An undocumented system needs more time inside it than a documented one, and the price reflects that, stated up front rather than discovered later. Everything after the assessment is priced by the report: a fixed price for each option.

Nothing changes during discovery. We read; we don't change. When work follows, it never touches your live data until it has proven itself somewhere else: built and tested against a copy in a test environment, then run in staging alongside the live system with the data migrated, checked and reconciled there first. Only when the tests have shown it's safe does anything connect to live, and the old system stays available as a fallback until you're confident.

Every month without documentation is a month the business runs on memory. People leave, and memory goes with them. A rewrite quoted without a map of the rules loses the rules, and they get rediscovered in production, one complaint at a time.

The documentation is also what makes a fixed price possible. Nobody can price what they can't see.

Understand first, then stabilise, then modernise one safe step at a time. Marc Allington leads the discovery and the work that follows. He has built business systems in VB, Access, SQL Server and .NET as well as on the web and in the cloud, so the code we're reading is usually a kind we've written ourselves. Everything we build afterwards runs on open, widely used technology, in your own accounts, with full source code and ownership transferring to you on final payment, and it comes documented.