The system is avoided
Change requests for a particular system are declined, deferred or routed around. The organization treats the risk of regression as too high to accept, often without acknowledging it formally.
Technical debt & modernization
Koi Consulting modernizes complete platforms and individual subsystems. Each system is reverse engineered from its behavior in production, rebuilt to be maintainable and verified against the existing system before cutover.
The problem
Every organization carries technical debt. It becomes a strategic issue when the system begins to dictate business decisions. Product plans are shaped by what the platform can accommodate, important changes remain in the backlog for years, and a response to a competitor’s move is estimated at eighteen months.
The conventional recommendation at this stage is a full rewrite in a modern language. Most of these programs fail for an identifiable reason. They attempt to change the language, the platform, the architecture and the behavior at the same time, and they discover in the second year that the behavior of the original system was never fully understood. The true specification was the code itself.
Our approach reverses this sequence. We first recover the actual behavior of the system and restore maintainability without changing anything else. We then demonstrate equivalence with evidence. Changes to architecture, language or platform follow only after that, each as a separate, reversible stage with its own exit criteria.
Diagnosis
Change requests for a particular system are declined, deferred or routed around. The organization treats the risk of regression as too high to accept, often without acknowledging it formally.
The written documentation and the system in production diverged years ago. Estimates are unreliable because the true specification exists only in the running code.
Institutional knowledge departed with individuals and was never captured in the code. The system continues to work, but no one can fully explain it.
A supplier has discontinued software on which your hardware or workflow depends, so the useful life of your asset is limited by another company’s product decisions.
Commercial decisions are shaped by what the system can accommodate, when they should be shaped by what the market requires. At this point technical debt has become a strategic constraint.
An earlier modernization effort was cancelled, reduced in scope or absorbed into other work. The debt has since grown, and the organization is less willing to try again.
Scope of engagement
When a platform is beyond incremental repair, we reverse engineer it, recover its actual behavior and rebuild it in stages against a verifiable reference, without a single irreversible cutover.
When one component is the constraint, such as a batch engine, rating logic, an integration layer or a reporting path, we isolate it behind a stable interface and replace it while the rest of the estate continues to operate.
When source code, documentation or the original developers are unavailable, or a vendor has discontinued a product, we recover the specification from the system itself, including binaries, wire protocols, file formats and undocumented interfaces.
The system remains in place and is made changeable again. The language and platform stay the same, behavior is preserved, and structure and documentation are restored. This is frequently the highest-value stage and almost always the first.
Method
Whatever the documentation states, the behavior that matters is the behavior in production. Modernization begins by recovering that behavior precisely, because downstream systems depend on it, including behavior that began as a defect.
Programs fail when language, platform, architecture and behavior change together. We separate them into stages with explicit exit criteria, so that a problem at any stage can be contained and reversed.
Running in parallel with the incumbent system, comparing outputs and investigating differences turns equivalence into something that is measured. A cutover should not depend on a test plan alone.
A system that your team can read, change and test is more valuable than one rewritten in a newer language that remains difficult to understand. Maintainability should be restored before any other change is made.
Case studies
Client identities are withheld as a matter of policy. The scale, constraints and elapsed time of each engagement are reported exactly.
Forty-one COBOL modules were reverse engineered from an undocumented production system and rewritten as maintainable production COBOL, ready for parallel testing as the first stage of a multi-stage modernization program.
A legacy insurance platform written in COBOL continued to carry production policy and claims workloads but had become difficult to maintain. The original developers had left the organization, and the documentation no longer matched the code. Because every change carried a significant risk of regression, the business had largely stopped making changes to the system.
The conventional alternatives were both unattractive. A full rewrite in a modern language would have required a multi-year program, a parallel organization and a cutover with limited ability to roll back. Continued patching would have increased the technical debt and left the platform constraining the pace of the business.
We recovered the actual control flow, data structures, copybook usage, batch and online paths, and the undocumented behaviors on which downstream systems had come to rely. The behavior of the system in production, more than its documentation, defined what had to be preserved.
The first stage left the language, the platform and the operating model unchanged and addressed maintainability alone. Rewriting the system as modern, structured and documented COBOL removed the largest risk, which was that the system could not be changed safely, without adding a simultaneous migration of language, runtime and skills. Changing one variable at a time is central to the success of this approach.
All forty-one modules were reconstructed with their observable behavior held constant, so that each could be validated independently and no single cutover was required.
The deliverable was production COBOL prepared to run in parallel with the incumbent system. The same inputs are processed by both systems, the outputs are compared and any differences are investigated, so that confidence rests on evidence.
Forty-one modules progressed from reverse engineering to production-ready COBOL in eleven hours of elapsed time and entered parallel testing as the first stage of a defined multi-stage program.
The client now has a codebase that its own team can read, change and test. This was achieved without a cutover event, a language migration or a multi-year budget commitment.
Reverse engineer and rewrite in place, with the same language and platform and with behavior preserved. Exit criterion: ready for parallel testing.
Run in parallel with the incumbent system, compare outputs and investigate differences until behavioral equivalence is demonstrated.
With a readable codebase and a proven equivalence harness, divide the monolith along service boundaries that reflect the current business.
Change the language or platform at this stage, when every step can be verified against a known reference and reversed if required.
Legacy modernization programs often fail because they attempt to change the language, platform, architecture and behavior at the same time, and later find that the behavior of the original system was never fully understood. Restoring maintainability first, and demonstrating it, allows every subsequent stage to proceed as a measured engineering decision.
A discontinued control-center application was reverse engineered and refactored to run on current Android, restoring full control of hardware that the manufacturer no longer supported.
A fleet of deployed hardware depended on a companion Android control-center application that the manufacturer had discontinued. No source code, updates or support were available. The application had been built for a version of Android several major releases old, and it no longer ran on current devices because of changes to the permission model, limits on background execution, deprecated connectivity APIs and target SDK requirements.
The hardware remained serviceable, with years of useful life ahead. The only obstacle to its continued use was software that was no longer maintained.
With no source code available, we reverse engineered the shipped package, including the application structure, resources, control flow and the state machine that governs interaction with the device.
The most valuable asset was the undocumented protocol between the application and the hardware. We reconstructed the command set, framing, handshake and response handling exactly, because the hardware could not be modified.
The recovered logic was rewritten for a current target SDK, with support for the runtime permission model, current connectivity and background execution requirements, modern lifecycle handling and current build tooling. This keeps the application compatible with future releases.
Correct operation was confirmed on the physical hardware across the full command set, without reliance on a simulated device.
In four days, an abandoned binary became a maintainable application running on current Android, with the full control surface restored and no modification to the hardware.
The owner recovered the useful life of its deployed equipment and now holds source code that it controls, so future Android releases can be addressed through routine maintenance.
Vendor abandonment is a form of technical debt that originates outside the organization and cannot be resolved through internal process. When the software that operates a hardware asset is no longer maintained, the life of that asset depends on the ability to reverse engineer its protocol. This is a specialized engineering discipline, and it is usually far less costly than replacing the hardware.
A legacy Laravel codebase with no maintainer was recovered, specified, rebuilt in function-based Rust and fully tested, reaching production readiness in fourteen days.
An abandoned Laravel application continued to carry production workload without a maintainer. As is common in framework-based projects that outlast their original team, business rules were distributed across controllers, models, middleware and service providers, behavior depended on implicit framework conventions, and no meaningful test suite described the intended behavior.
As a result, the application was difficult to reason about. Operating costs were high, correctness could not be verified, and the framework version was too old for a straightforward upgrade. The application nevertheless remained essential to the business.
We recovered the behavior of the application in production, including request paths, data access, business rules and the behavior produced by framework conventions. In abandoned framework applications, much of the specification resides in this implicit behavior.
The recovered behavior was recorded as an explicit specification before any code was written. This document serves as the reference against which the rewrite is tested, and it is a deliverable in its own right that gives the client a complete description of its system.
The application was rebuilt in explicit, function-based Rust. Data flow is visible in function signatures, errors are handled as values, and the compiler enforces at build time many of the invariants that the original application maintained only by convention.
The test suite was written against the recovered specification, independently of the new implementation, so that it validates behavioral equivalence.
In fourteen days, an abandoned and undocumented Laravel codebase became fully tested, production-ready Rust supported by a written specification.
The client now has an application with explicit control flow, compiler-enforced invariants, a complete test suite and materially lower operating cost, together with documentation that describes its behavior.
Language migration is normally the final stage of modernization. When the source is already abandoned and unmaintainable, however, recovering the specification and rebuilding explicitly is often more economical than restoring a framework that the team no longer understands. The specification is the most important deliverable, because it makes future change safe.
Where the standard driver had become the constraint, we developed a purpose-built binary protocol client for the client’s specific access pattern, which measured one third less latency and one third less bandwidth.
An enterprise platform had exhausted the usual options for improvement. Queries were tuned, indexes were correct, connection pooling was in place and hardware was not the limiting factor. The remaining constraint was the database driver, a general-purpose client designed to serve every workload, which carried per-request overhead and network redundancy that this access pattern did not require.
At this point many engagements conclude with a recommendation for additional hardware, because the remaining inefficiency lies at a level that few teams are equipped to address.
We profiled the MySQL binary protocol exchange itself, including round trips, packet composition, result-set encoding, prepared-statement handling and type marshalling, to establish precisely where time and bandwidth were being consumed.
We developed a purpose-built client that speaks the MySQL binary protocol and implements only the functions this workload requires. The improvement comes from this specialization, because a driver designed for a single access pattern can be optimized precisely for it.
The access pattern was restructured at the protocol level, with statement handling, result encoding and marshalling tuned to the client’s data, reducing both the number of exchanges and the size of each.
Correctness and performance were both measured against the incumbent driver under representative production load, so the 33% result reflects a direct comparison.
The client achieved a 33% improvement in both latency and bandwidth relative to the standard driver, with no schema change, no query rewrite and no additional hardware.
The benefit compounds. Lower latency per request increases effective concurrency on the same infrastructure, and lower network volume reduces cost on every metered network path.
When standard tooling becomes the constraint, the most effective response is often to work one layer lower in the stack. Few firms will implement a database wire protocol to recover a third of a platform’s latency. This kind of engagement draws on experience at carrier scale, where an improvement of that size is material.
Common questions
Yes. Koi Consulting rewrites whole platforms and individual subsystems. The firm reverse engineers the system as it behaves in production, rebuilds it to be maintainable, and verifies the result against the incumbent system through parallel running before any cutover. Work is delivered in stages with explicit exit criteria, so no single large-scale replacement is required.
Koi Consulting reverse engineered an entire legacy insurance COBOL system and rewrote 41 separate modules as maintainable production COBOL in 11 hours of elapsed time, delivered ready for parallel testing as the first stage of a multi-stage modernization program. Timelines depend on system size and coupling, but restoring maintainability can be measured in hours and days, compared with the multi-year schedules of conventional rewrite programs.
Changing the language, the platform, the architecture and the behavior at the same time is the reason most modernization programs fail. The first stage changes only maintainability. The language and platform stay the same, behavior is preserved, and structure and documentation are restored. This removes the largest risk, which is that the system cannot be modified safely, without requiring a simultaneous migration of runtime and skills. Language or platform migration then becomes a later stage that can be verified separately.
Yes. Koi Consulting reverse engineered an abandoned Android control-center application for legacy hardware that the manufacturer no longer supported. With no source code available, the firm recovered the application logic and the undocumented device wire protocol from the shipped binary and refactored the application onto a modern Android baseline in four days. The hardware required no modification, and the owner now holds source code that it controls.
A maintainability recovery engagement makes an existing system changeable again without replacing it. The language, platform and observable behavior remain constant while structure, readability and documentation are restored. It is frequently the highest-value stage of a modernization program and almost always the first, because every later stage depends on the ability to read and test the system.
Koi Consulting demonstrates equivalence through parallel running. The same inputs are processed by the incumbent system and the rewritten system, outputs are compared at the record level, and differences are investigated until behavioral equivalence has been demonstrated. Confidence is based on measurement.
Yes. Koi Consulting reverse engineered an abandoned Laravel application, produced the written specification that had never existed, refactored it into function-based Rust, and delivered it fully tested and production ready in 14 days. Explicit, function-based Rust makes data flow visible in function signatures and allows the compiler to enforce many invariants that were previously maintained by convention.
Yes. When standard tooling is the constraint, the firm works at a lower layer of the stack. For an enterprise client whose queries, indexes and connection pooling were already correct, Koi Consulting developed a custom client that speaks the MySQL binary protocol and is optimized for that client’s access pattern. It measured a 33% improvement in both latency and bandwidth compared with the standard driver, with no schema change, no query rewrite and no additional hardware.
Next step
We will advise whether your system needs a rewrite, a subsystem replacement or a maintainability recovery, and what the first stage will cost.