We verify exactly what you’re asking us to price and against which constraints, before any number gets attached. Every delivery option that could apply is logged with its evidence, because an option missed here never gets costed, so nothing moves forward until the inventory is confirmed against source code.

We check whether your documentation and your code actually agree — building as-is and to-be maps and an interface table, then cataloguing every contradiction between documents, interviews, and source. Where they diverge, the code wins, and the gap becomes a tracked finding in the estimate.

We measure how much of your system genuinely has to be rebuilt — module by module, file by file, with generated, vendored, duplicated, and out-of-scope volume identified and excluded by name. Inflated line counts get corrected in both directions: dead code stops being priced as work, and hidden risk stops being invisible to the count.

We reverse-engineer the specification your system was never given — every process, state machine, permission, and screen, indexed as numbered, complexity-banded requirements that hours can attach to. Effort is estimated against what the system actually does, since line counts mislead in either direction.

For every subsystem, we decide what can be kept and what must be rebuilt, and name the ongoing compatibility cost of each freeze decision. Some legacy components are a portable core in a platform-specific shell, and porting them costs far less than a rebuild.

We judge every target technology against the same requirements — suitable, awkward, or fails, no favorites — and hand over a distilled manifest your estimate is built from. The decision is documented against evidence, independent of the stack our team prefers to build in.