Skip to content

system audit

Legacy code audit: the whole system mapped and priced in 5 days

In 5 days you know what your system contains, what is dead, what is dangerous and what replacing it costs. Engineers with 25+ years in production read every line, and 30 days after you approve the plan you are live.

Send read access today. In 48 hours you have the audit price and the day the report lands.

Unknown

A source tree of unknown size, jobs nobody documented, and no tests to lean on.

  • source treeunknown size
  • nobody left who wrote itrisk
  • undocumented jobscron · JCL
  • no testscoverage 0

5 days from read access to the finished report

Mapped

Module map, measured dead code, ranked risks, and a plan with a price on every phase.

  • module mapgraph
  • dead code listmeasured
  • risk registerranked
  • migration planphased · costed
The map and the plan are yours to keep. Approve the first phase and the 30 days of the rewrite start.

From read access to a signed plan in 5 days

A machine pass over every line, an engineer over everything it flagged, then a session where you press on the findings until the plan is one you would sign.
  1. 01days 1–2

    Access and interviews

    Read access to the repositories, build instructions, job schedules, and two or three hours each with the people who maintain it. We sign your NDA before any of it.

  2. 02days 1–3

    Machine pass

    The platform parses everything: call graph, module boundaries, external interfaces, database usage, reachability. The module in a dialect nobody supports gets parsed too.

  3. 03days 3–4

    Engineer pass

    An engineer with 25+ years in production works through what the machine flagged and checks it against what your people said. Where the two disagree, the code wins.

  4. 04days 4–5

    Findings and plan

    A written report and a working session: the dead code, the risks ranked by what they cost you, a price on every rewrite phase, and what goes first. Approve it and the 30 days start.

Every line by machine, every finding by an engineer

The platform reads every line and misses the context. Interviews supply the context and miss half the code. Our engineers put both into a plan you can sign.
  • Parsing and graphing the whole codebase

    Platform

    Every language in the tree, including the ones you forgot were in there.

  • Measuring dead code

    Platform

    Static reachability plus production traces or logs. Dead code becomes a number you can put in a budget.

  • Interviews with the people who know it

    Engineer

    What was never written down exists only in conversation. We get it on paper before its owner retires.

  • Ranking the risks

    Both

    The platform finds the sharp edges. An engineer ranks them by which one costs you money on a Friday.

  • Pricing the phases

    Engineer

    From measured module sizes and coupling, with the assumptions written next to every number.

  • The recommendation

    Engineer

    What goes first, what gets deleted, and the order that puts the new system in production by day 30.

The report is written for your engineers first and your board second. Both can act on it the day it lands.

Who reads your code

Our engineers have written production code for more than 25 years, and they are the best people you can put in front of your source tree. Dozens of migrations out of COBOL, RPG, VB6, Delphi, ColdFusion, PHP, Perl, PL/SQL, Java, C#, Fortran and ABAP, plus dialects that exist inside one company. Very little in your repository will be new to them.

Fixed price, the delivery day in the contract, and the report is yours to keep. The plan inside carries the same terms: a fixed price per phase, and parity or the phase is not accepted.

What CTOs ask before an audit

How much access do you need?

Read access to the repositories and the build instructions. Add job schedules and a period of production logs, and we measure dead code from real runs. Send what you have today and we start on day 1.

What about the parts we have no source for?

They go on the map as exactly that: a binary, its interfaces, and what replacing it takes. Migrations blow their budget at the end on the parts somebody left off. Send us the list of what you know is missing and we price it too.

Our system is huge. Is 5 days still enough?

Yes. Above roughly two million lines, or with many languages in one tree, we split the audit into parts and price each one up front, and each part lands in 5 days. Send the line count and get the split with prices in 48 hours.

Will you sign an NDA before we send anything?

Yes, before any access, every time. Most of our work starts under one. Attach yours to the form and we sign it before we look at a line.

Why audit first instead of going straight to the rewrite?

The audit is where the price comes from. In 5 days every phase of the rewrite has a measured size and a fixed price, and the work starts on numbers your engineers have checked. Approve the first phase and the 30-day clock starts.

Get the map of your system

Read access is all we need. Within 48 hours you have the price and a delivery day, and 5 days after access the map, the ranked risks and the costed plan are on your desk.

Get a quote

Ten minutes to fill in. The engineer who replies asks about access first, so have the repo list ready.