Skip to main content
Legacy Modernization

Risk-Minimised Legacy Modernization: Future-Proof Your Battle-Tested Business Logic.

Legacy systems are a strategic growth inhibitor. When monoliths grown over decades paralyse your release cycles, mainframe operating costs rise and the know-how of your original developers gradually retires with them, regulated industries come under massive innovation pressure. itemis breaks this vicious cycle with a methodical, incremental migration approach, without Big-Bang risk.

The Typical Starting Point

Legacy Systems Are Holding You Back

Paralysed Release Cycles

Monoliths grown over decades paralyse your release cycles. Every change becomes a risk project. Innovation pressure rises, agility declines.

Rising Costs, Vanishing Know-How

Mainframe operating costs rise continuously. At the same time, original developers gradually retire, taking undocumented system knowledge with them.

The Fear of the Big Bang

The complete, risky replacement of the system on a single cut-over date often leads to years of standstill. Technical debt and operating costs keep growing unimpeded.

Our Approach

What Does Legacy Modernization Mean at itemis?

Successful system modernisation is far more than simple replatforming or cosmetic refactoring. It is the controlled extraction and evolution of business-critical domain knowledge. Blindly translating old code one-to-one into a new language merely copies the architectural mistakes of the past into a new ecosystem.

Our modernisation approach rests on two quality commitments: functional correctness (100 % semantic equivalence to the legacy system) and maintainability (generation of modern, idiomatic target code without proprietary dependencies).

We view legacy systems as the valuable, generation-tested foundation of your success. Instead of incalculable all-or-nothing operations, we deliver a methodical, incremental migration approach: through the combination of classical software craftsmanship and AI-assisted analysis and migration toolchains.

Methodology

No Big Bang: the Strangler-Fig Pattern

Rather than switching off the legacy system in a risky “Big Bang”, the new system grows incrementally around the old one, replacing it function by function, like the strangler fig that gradually encloses its host tree.

No Big-Bang Risk

Legacy and new system run in parallel. There is no single critical date by which everything must work at once.

Always in Production

Business operations and release capability remain intact throughout the entire migration.

Incremental Value Delivery

Already migrated components deliver immediate benefits (e.g. lower operating costs, better maintainability) rather than waiting until the end of the project.

Reversibility

Every migration step is small, isolated and reversible if needed. The overall risk is decomposed into many small, manageable risks.

Continuous Validation

Every replaced function is verified against the original behaviour before the next step begins.

Incremental Investment Approval

Instead of a total budget for a multi-year project, investments can be approved iteratively and tied directly to visible results.
The Core Process

The Five-Stage Model: Safety at Every Stage

Our core promise: we have strong guarantees at every stage that the original functionality is preserved, because a green test suite is present at every point in time. The individual stages build on each other:

Stage 1: Classical, rule-based transpilation: A deterministic transpiler produces a semantically exact 1:1 mapping of the legacy code in the target language. This runnable reference is the safety net, no AI, no hallucination risk.

Stage 2: Test generation & trace recording: Using the runnable reference as a baseline, we record real trace logs and automatically generate a complete test pyramid. These tests approximate a “manifold” around the actual system behaviour and make that behaviour measurable.

Stage 3: Code documentation & reverse engineering: AI-assisted extraction and documentation of system architecture, business logic and dependencies: the knowledge foundation for safe refactoring and subsequent know-how transfer.

Stage 4: Custom tooling & MCP server: Project-specific tools and a context-loaded MCP server give the AI a precise semantic frame that structurally excludes code anomalies.

Stage 5: AI-based Spec-Driven Design refactoring with expert knowledge: Only now do we transform the code into a modern, idiomatic target architecture. Every transformation is validated against the test pyramid and reviewed by senior architects (Human-in-the-Loop).

Because a complete test pyramid enclosing the original behaviour is present at every point in time, we guarantee preservation of the original business logic, while delivering readable, maintainable and modularly structured code.

Technology Portfolio

Migration Paths: Bridges Between Technology Generations

Every legacy system requires a tailored strategy. We have the tools and expertise to disentangle grown monoliths step by step.

Mainframe & Core Migration

PL/I, COBOL, RPG, Assembler → Java (Spring Boot, Quarkus), Go. Drastic reduction in mainframe licence costs (MIPS); independence from the shortage of specialist developers.

Monolith to Microservices

Legacy Java EE (EJB), C++, .NET Framework → Cloud-Native, Docker, Kubernetes. Dramatically accelerated release cycles via the Strangler-Fig pattern, in live operation.

Database & Schema Evolution

DB2 z/OS, IMS/DB, complex stored procedures → Cloud-Native PostgreSQL. Breaking down data silos; use of modern migration tools (e.g. pgloader, pgTAP for unit testing).

Architecture Modernization

Domain-Driven Design (DDD), Clean Architecture, API-First (REST, gRPC). Restoring maintainability; eliminating technical debt and vendor-specific lock-in.
Quality Assurance for Critical Systems

Three-Pillar Safeguarding for Critical Systems

01

Three-Pillar Test Data Concept

For comprehensive coverage we combine operational test data from your production environment, hand-written edge-case tests for critical mathematical business logic (e.g. commission and rounding rules) and AI-generated synthetic datasets to simulate extreme load scenarios in advance.

02

Trace-Based Validation Process

Both the transpiled reference code and the final, AI-optimised Java code are instrumented so that all accesses to external environments (databases, files, interfaces) are logged in detail. An automated behaviour review compares these trace outputs in real time: every deviation is immediately localised.

03

Cost Efficiency through Degressive Cost Curves

The bulk of our effort goes into the one-time setup and calibration of the migration toolchain. Once in place, costs decrease degressively: higher code volumes do not lead to proportional cost increases. The price per line of code (LOC) decreases significantly for follow-on projects.

Data Sovereignty & AI Security

Your Code Stays Under Your Control

For banks, insurers and the public sector, the critical question about AI-assisted work is: “Where does our source code go?” Our answer: we align usage strictly with your compliance requirements. We have the expertise to cover the full spectrum; price and timeline vary depending on the level of restriction.

Operating Models: from Cloud Standard to Complete Isolation

On-premises: Full operation within your own environment is possible; we advise and accompany the corresponding setup.

European hosting with open-source models: Data processing within the EU with open-source models for maximum transparency and data sovereignty.

Dedicated, isolated infrastructure: Dedicated machines with additional protective measures, and closed-source models via controlled environments (e.g. Azure and comparable providers).

Open-weight models for highly sensitive cases: For particularly critical code, we use open-weight systems and achieve comparable quality, at correspondingly higher effort and price.

Consistent Governance Principles

Human-in-the-Loop: Every AI generation is subject to mandatory expert review.

GDPR-compliant & traceable: Transparent, controlled and deterministically reproducible AI usage.

Provider independence: Open-source practices, no proprietary lock-in. The MCP server remains with you licence-free.

No model lock-in: The approach is provider-independent: models and tools are interchangeable.

Whether public-cloud efficiency or maximally isolated processing: we have the knowledge and tools to handle any case securely. Security requirements can affect price and timeline, but never the quality of the result.

Our Process

An Example Project Blueprint: Five Structured Work Packages to the Goal

To deliver legacy system modernisation with maximum transparency, control and schedule reliability, we work along clearly defined milestones:

Work Package 1: Analysis and Test Setup: Detailed, automated capture of the current state (codebase) and comprehensive documentation of the existing system architecture. Building the test pyramid, defining mapping rules and data mapping for the PostgreSQL target model.

Work Package 2: Automated Code Transformation: Machine-based, rule-driven translation of the source code into the target language to establish a functional, error-free reference baseline. Systematic comparison and validation of the new code using the prepared tests.

Work Package 3: Refactoring and Architecture Optimisation: AI-assisted revision and structuring of the transformed code. Migration into a modern, maintainable and idiomatic target architecture using advanced developer tools. Continuous validation against the original system behaviour.

Work Package 4: Database and Data Migration: Tool-assisted transfer and adaptation of data structures and database schema to the target system. Provision of installation and migration scripts, and verified test migrations in isolated environments.

Work Package 5: Go-Live, Handover and Knowledge Transfer: Complete, turnkey handover of the modernised source code, system documentation, tools used and migration scripts. Structured feedback rounds and training sessions secure the transfer of knowledge to the internal teams.

Proven Practice

Our Modernisation References

We deliver large-scale projects in heavily regulated core domains. Our successful engagements include:

Société Générale (Host & Test Automation): Cloud migration of a business-critical core banking system from a grown mainframe architecture. Volume: 10 million lines of code, 17,000 programs, 12,000 batch jobs. Specialised tools achieved an automation rate of 99.99 %. Functional equivalence was verified error-free via automated production traces (Capture & Replay) in real-time comparison; hundreds of person-days in testing were saved in the process.

Zurich Group (Legacy Migration & DSL Build): Structural consolidation and highly automated migration of approximately 200,000 lines of historically grown mathematical C code for life insurance into a domain-specific language (DSL). The previously up-to-four-week manual programming phase per release was completely eliminated; an integrated code generator produces immediately testable code.

APG Affichage (Oracle Forms → Java): Complete migration of a historically grown Oracle Forms application into a modern Java architecture including project management, legacy system analysis and DSL-based migration methods. The user interface was automatically and error-free regenerated via code generation. Stack: Java, Spring, Oracle RDBMS, JPA, JSF, Eclipse GMF, Xtext.

Large Life Insurance Legacy System (Know-How Preservation): Model-based, highly automated migration to drastically reduce maintenance costs and safeguard against demographic change in the IT team. Extremely short freeze time, parallel development of legacy and new system, 100 % freely definable target architecture.

International Reinsurer (Mainframe Replacement): Technical project coordination for the migration of a complex host claims calculation application (commission and settlement logic) to a modern Java platform, including algorithm optimisation, a modern testing strategy and a quality management manual.

Deutsche Bahn & parcIT (AI-Assisted Toolchain): Building an AI-assisted toolchain integrated directly into existing development processes, including MCP servers, IDE integrations, an automated review bot anchored in JIRA/Confluence and a business analyst tool. Evidence of controlled, deterministic and traceable AI usage including change management and know-how transfer.

Generali (since 2019): Long-term partnership covering architecture consulting, language engineering and continuous performance optimisation of business-critical systems.

Frequently Asked Questions

Frequently Asked Questions about Legacy Modernization

Do we have to shut down our legacy system for the migration?
No. We work according to the Strangler-Fig pattern: legacy and new system run in parallel, functions are replaced step by step. There is no risky “Big Bang”, business operations continue throughout the entire migration.
How do you ensure that 100 % of the business logic is preserved?
Through the five-stage model with continuous safeguarding: a deterministic transpiler first creates a semantically exact reference (stage 1). From that, we generate a complete test pyramid and compare the behaviour of the legacy and target systems via trace logs in real time (stage 2). All further stages are validated against this test pyramid. A green test suite is present at every point in time.
Doesn't the AI hallucinate and silently introduce errors?
We eliminate this risk structurally. The actual technology switch is performed rule-based, without AI. We only use generative AI in the refactoring step, embedded in Spec-Driven Design, safeguarded by the test pyramid and mandatory expert reviews (Human-in-the-Loop).
Where does our source code go, and is the AI usage GDPR-compliant?

Wherever your compliance permits. Options include on-premises operation, European hosting with open-source models, dedicated isolated infrastructure and closed-source models via controlled environments (e.g. Azure). For highly sensitive cases, we use open-weight models.

Our AI usage is transparent, controlled, deterministically reproducible and provider-independent. No proprietary lock-in is created; the MCP server containing your project knowledge remains with you licence-free.

Which source and target technologies do you support?
On the source side: PL/I, COBOL, RPG, Assembler, Java EE, C, C++, .NET and DB2 z/OS and IMS/DB, among others. On the target side: modern Java architectures (Spring Boot, Quarkus), Go, cloud-native stacks (Docker, Kubernetes) and PostgreSQL.
How long does a modernisation project take?
This depends strongly on scope and complexity. As a rough guide, a typical engagement is in the order of approximately one year; a reliable estimate is provided after the analysis phase (Work Package 1).
What happens to the knowledge after the project ends?
It stays with you. The fully documented MCP server serves your team as a living knowledge base. Through training and coaching, we equip your internal teams to independently maintain and evolve the new system.
What if a migration is not economically viable?
Then we will tell you. If an integration audit reveals that encapsulating certain system components is more cost-effective than migrating them, we communicate this openly. Transparency takes precedence over a quick project close.
Do costs scale linearly with code volume?
No. The bulk of effort goes into the one-time calibration of the toolchain. After that, a degressive cost curve takes effect: higher code volumes do not lead to proportional cost increases. The price per line of code (LOC) decreases significantly for follow-on projects.
How do you handle critical batch processing and tight batch windows?
Performance and stability under load are integral parts of our target architecture. In reference projects (e.g. 12,000 batch jobs at Société Générale), we have demonstrated adherence to batch windows and mastery of massive, batch-oriented processing.
Our Experts
Holger Schill

Executive Vice President Cloud & Enterprise · itemis AG

Holger Schill is Executive Vice President Cloud & Enterprise at itemis. Since 2008, he has shaped the domain for modern cloud solutions, automation and AI agents, successfully delivering dozens of client projects. The author of numerous publications shares his expertise through training sessions, as a speaker at international conferences, and as a long-standing committer on the open-source project Eclipse Xtext. He is currently focused on the strategic simplification of complex systems.
Christoph Hess

Head of Artificial Intelligence · itemis AG

Christoph Hess is Head of Artificial Intelligence at itemis and has been specialising since 2021 in the technological evolution from classical machine learning algorithms to the integration of autonomous AI agents into complex enterprise environments. He analyses how organisations can deploy AI strategically and writes about autonomous agent systems, AI architectures and the practical integration of AI into enterprise processes.
Get Started

Turn Your Legacy System into an Innovation Driver

Schedule a call with Holger Schill and Christoph Hess.

Knowledge

Insights on Legacy Modernization

References

From the Field