At a Glance

From 15 Years of PHP Monolith to a Layered Java Architecture

A central ERP and financial system carries ten business domains in a single codebase. Over 15 years, around 200 elementary processes and proprietary components had been added, including a custom state machine and a custom formula language. The specification existed in the code and in the minds of the developers, not in any documentation. We measured the system first, then reconstructed its business logic using AI, and finally migrated it to a layered target architecture built on Java Spring Boot.

65 Person-Days

of human effort across all four phases

Factor 8

less effort compared to conventional approaches

10 Business Domains

fully specified and migrated

1,100 Function Points

measured and documented to ISO 14143

The Challenge

A stable system quietly accumulating technical debt.

The system was running stably and had largely been written off. Day-to-day operating costs attracted little attention, yet technical debt continued to grow. Ten business domains shared a single codebase, permissions and process control ran on custom-built components, and schema changes were made by hand.

Three options were on the table. Continuing as-is simply defers the problem. A complete rebuild with equivalent functionality ties up a budget that creates no additional business value. A lengthy analysis phase consumes months of capacity across the business and typically ends with slide decks rather than results.

There was a further complication: the system had no written specification. Its logic lived in the code and in the institutional knowledge of individual developers. Any modernisation effort launched without first reconstructing that knowledge would have been built on uncertain ground.

The Solution

Measure first, understand second, build third — each phase delivering a result that stands on its own.

We chose a fourth path: measure first, understand second, build third. Each phase delivers a result that is usable independently of what follows. From the outset, the business, IT and procurement teams worked from the same set of numbers.

The starting point was an AI-assisted function point analysis to ISO 14143. The method is established and vendor-neutral. It measures functional scope across inputs, outputs, data stores and interfaces, providing an objective basis for effort and budget estimates before a single euro of development budget is committed.

In the second phase, we reconstructed the business logic from three independent sources: source code, existing documentation and automated tests running against the live system. This produced a complete domain model, structured use cases, and rules and algorithms in pseudocode. In the third phase, we defined the target architecture: strictly layered, one package per business domain, dependencies flowing downwards only. Four proprietary components were replaced by established standards.

In the implementation phase, a squad of more than ten AI agents worked in parallel across design, implementation, testing and quality assurance. Experienced developers managed the orchestration and made all significant architecture and quality decisions. Because the requirements from phase two were complete and unambiguous, the agents were able to work in parallel effectively.

Function Point Analysis to ISO 14143

Vendor-neutral measurement providing an objective basis for effort and budget decisions

AI-Assisted Reverse Engineering

Business logic reconstructed from source code, documentation and automated tests

Complete Specification

Domain model, use cases and algorithms documented in pseudocode

Layered Target Architecture

ava Spring Boot, one package per business domain, dependencies downwards only

AI Agent Squad

More than ten agents working in parallel across design, implementation, testing and QA

Market-Standard Technologies

Java, Spring Boot, MariaDB, Flyway, Flowable and Docker — widely available in the talent market

The Result

65 person-days of human effort, where conventional projects require over 500.

Across all four phases, human effort totalled 65 person-days, compared to over 500 in a conventional approach. The work does not disappear — it shifts from writing to reviewing and deciding.

The ISO 14143 measurement required 3 person-days, against around 15 in a conventional project. Specifying the business logic took 7 person-days, compared to around 120. Architecture planning and decision-making accounted for 5 person-days instead of around 40. Implementation concluded at 50 person-days, where projects of this size conventionally budget around 330.

Beyond the reduction in effort, the project delivers two further outcomes that extend well past go-live. For the first time, the system’s business knowledge is fully documented: domain model, use cases and calculation rules are committed to writing and remain available to the organisation regardless of which individuals leave in future. And the target architecture is built on technologies with broad market availability. Long-term operations and maintenance remain plannable, and the freedom to choose who develops the system further is preserved.

PhaseEffortConventional Benchmark
Measure3 PDapprox. 15 PD
Understand7 PDapprox. 120 PD
Plan and decide5 PDapprox. 40 PD
Implement50 PDapprox. 330 PD
Total65 PDover 500 PD
Factor 8 Less Effort

65 instead of over 500 person-days of human work

Business Knowledge Documented

Domain model, use cases and algorithms committed to writing for the first time

Future-Proof Target Architecture

Market-standard technologies, free choice of operator and development partner

10 Business Domains Migrated

Fully specified and architecturally separated into clean packages

4 Proprietary Components Replaced

State machine, formula language, permissions system and schema changes replaced by standards

Reliable Cost Foundation

Function point analysis completed before development budget was committed — business, IT and procurement aligned on one number

“This project demonstrates what structured AI-assisted modernisation can achieve in practice.”

Our Contribution

We did not simply transform code. We first understood what the system does, why it was built the way it was, and what logic it carries. Only on that basis did we build.

The approach is repeatable. What we applied here can be transferred to any legacy system that has grown over years and whose documentation no longer reflects reality. The function point analysis creates transparency before budget decisions are made. The AI-assisted specification makes implicit knowledge explicit. And the layered target architecture ensures that the new system does not face the same problems in ten years that the old one faces today.

Contact

How much technical debt are your applications carrying?

Select one or two applications with us. We measure them and provide you with a reliable proposal for their replacement.

Send an email
Portrait photo of Martin Cremer, Head of Cloud Solutions

Martin Cremer

Head of Cloud Solutions & Managed Services
LinkedIn