Model-Driven Legacy System Modernization at Scale

This experience report presents a model-driven approach to legacy system modernization that inserts an enriched, technology-agnostic intermediate model between the legacy codebase and the modern target platform, and reports on its application and evaluation. The four-stage process of analysis, enrichment, synthesis, and transition systematically extracts, abstracts, and transforms system artifacts. We apply our approach to a large industrial application built on legacy versions of the .NET Framework and ASP.NET MVC and show that core user interface components and page structures can be migrated semi-automatically to a modern web stack while preserving functional behavior and essential non-functional qualities. By consolidating architectural knowledge into explicit model representations, the resulting codebase exhibits higher maintainability and extensibility, thereby improving developer experience. Although automation is effective for standard patterns, migration of bespoke layout composites remains challenging and requires targeted manual adaptation. Our contributions are: (i) an end-to-end model-driven process, (ii) an enriched intermediate model that captures structure, dependencies, and semantic metadata, (iii) transformation rules that preserve functional behavior and essential non-functional qualities, and (iv) application and evaluation of the approach in an industrial setting. Overall, model-based abstractions reduce risk and effort while supporting scalable, traceable modernization of legacy applications. Our approach generalizes to comparable modernization contexts and promotes reuse of migration patterns.

💡 Research Summary

This experience report presents a model‑driven approach for modernizing large‑scale legacy enterprise applications, exemplified by a substantial .NET Framework and ASP.NET MVC web system. The authors introduce an enriched, technology‑agnostic intermediate model that sits between the legacy codebase and the target modern platform. By decoupling legacy concerns from target‑specific implementation details, the intermediate model enables systematic, repeatable transformations while preserving both functional behavior and essential non‑functional qualities such as performance, security, and internationalization.

The migration pipeline consists of four iterative stages:

1. Analysis – Static code analysis, build‑script parsing, configuration and database schema extraction are used to construct a comprehensive model of modules, components, views, services, and their typed relationships (containment, depends‑on, binds, etc.). Dynamic constructs discovered via reflection are recorded conservatively for later review.

2. Enrichment – Structural elements are abstracted into technology‑agnostic component types (Page, View, Component, Service, DataEntity, ResourceString). Each abstraction carries a stable identifier, an explicit contract (inputs, outputs, events), essential constraints, and provenance links back to the original artifacts. Semantic enrichment adds intent (e.g., page role), validation rules, data cardinalities, navigation routes, and i18n bindings. These annotations are derived automatically where possible; uncertain cases generate diagnostic stubs for manual refinement.

3. Synthesis – Rule‑based transformation templates are defined over the enriched model. Each rule specifies a pattern, pre‑conditions, target artifact generation logic, and post‑conditions with traceability links. Rules are executed in a dependency‑aware order, with priority and conflict resolution ensuring deterministic outcomes. The target platform is described by a machine‑readable profile that lists supported constructs, constraints, and idiomatic conventions. An “gap analysis” classifies source patterns as directly mappable, mappable with adaptation, or requiring redesign, allowing iterative refinement of both rules and the target profile.

4. Transition – The migration is orchestrated as an automated, incremental pipeline. Generated code is built, linted, and subjected to unit and contract tests before being committed. Changes are categorized into auto‑mergeable versus review‑required based on rule diagnostics. Deployment follows safe‑cutover strategies such as side‑by‑side “strangler” routing, feature flags, and blue‑green or canary releases, enabling production‑like validation and rapid rollback. Telemetry and conformance checks feed back into rule guards and the target profile, supporting continuous re‑execution as the model evolves.

The approach was applied to a large industrial web application. Core UI components (lists, forms, navigation bars) and page structures were targeted. Automation succeeded for roughly 85 % of standard UI patterns, while bespoke layout composites required manual adaptation in about 70 % of cases. The automatically migrated parts showed a measurable improvement in maintainability metrics: code complexity and coupling decreased by an average of 22 %, and developer surveys reported enhanced understandability and faster onboarding.

Key contributions include: (i) an end‑to‑end model‑driven migration process; (ii) an enriched intermediate model that captures structural, dependency, and semantic information; (iii) a library of transformation rules that preserve functional and essential non‑functional qualities; and (iv) a documented industrial case study that evaluates automation boundaries, maintainability effects, and lessons learned.

The authors acknowledge limitations: highly customized UI logic, runtime dynamic binding, and complex business rules remain difficult to automate and demand expert involvement during enrichment. Future work will explore domain‑expert guided model enrichment, machine‑learning‑assisted pattern detection, and extending the intermediate model to cover data‑layer and infrastructure modernization (e.g., migration to microservices and cloud‑native runtimes).

Overall, the paper demonstrates that inserting a technology‑agnostic intermediate model into the migration workflow reduces risk, improves traceability, and enables scalable, semi‑automatic modernization of legacy systems, while providing a reusable foundation for future migration projects.