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 — an option missed here is an option that never gets costed, so nothing moves forward until the inventory is confirmed against source, not assumption.

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; the gap becomes a tracked finding, not a guess baked into 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 gets estimated against what the system actually does, not against a line count that misleads 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. Not every legacy component is a liability, some are a portable core in a platform-specific shell, and rebuilding them anyway is an unnecessary cost you don’t need to pay.

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, not against which stack our team prefers to build in.