NCompas transforms Java EE monoliths, Delphi systems, Classic ASP, and .NET Framework applications into cloud-native, AI-embedded platforms — using incremental patterns that deliver user value throughout, not after a 2-year big-bang rewrite that has a 70% failure rate.
Why NCompas
The failure mode of modernisation is not bad code — it's the wrong approach: too much upfront, too long before users see value, too little domain understanding.
Big-bang rewrites have a 70% failure rate (Standish Group). We don't propose them. Every modernisation engagement uses incremental patterns — strangler fig, branch-by-abstraction, anti-corruption layers — that deliver user-visible value throughout the migration, not after a 2-year dark-room rebuild.
Modernisation without AI integration is just technical maintenance. Every application we modernise is designed with AI embedding in mind: semantic search over the data layer, Azure OpenAI copilot features in the new UI, document processing pipelines replacing manual data entry. The modernised system is an AI-native application, not just a cleaner version of the legacy one.
Modernising a 20-year-old application means understanding the domain logic it encodes — the business rules, edge cases, and exception handling written in response to real events that are now institutional knowledge trapped in legacy code. We invest in understanding the domain before decomposing it, so the new system works the way the business does.
Understanding 500,000 lines of undocumented legacy code used to take 6 months. Azure OpenAI-assisted static analysis, code summarisation, and dependency mapping reduces this to 4–6 weeks. We use AI to analyse the legacy system, document its behaviour, identify decomposition seams, and generate test harnesses — so modernisation starts from a position of understanding, not guesswork.
A modernised application deployed the same way as the legacy system is still fragile. CI/CD pipeline, infrastructure as code, test automation, and observability are not optional extras — they are part of the modernisation deliverable. DORA metrics (deployment frequency, lead time, MTTR, change failure rate) are baselined at start and tracked throughout.
Legacy systems create consultant dependency — the worst outcome is replacing that dependency with a different one. Every modernisation engagement includes documentation (Architecture Decision Records, runbooks, onboarding guides), pair programming with internal engineers, and a structured handover programme. The goal is a team that owns and can evolve the new system independently.
Six modernisation capability domains
Six practices that work together: assessment identifies the patterns, decomposition applies them, AI embedding makes the modernised system genuinely better than the original.
Before any code is written, we map the full legacy estate: technology stack, business capability dependencies, integration complexity, data ownership, team knowledge concentration, and technical debt hotspots. AI-assisted static analysis tools (SonarQube, NDepend, Architecture Analyzer) accelerate this dramatically. Output is a 90-day, 180-day, and 12-month modernization roadmap with effort estimates, risk tiers, and prioritised quick wins that fund the longer migration.
Before any code is written, we map the full legacy estate: technology stack, business capability dependencies, integration complexity, data ownership, team knowledge concentration, and technical debt hotspots. AI-assisted static analysis tools (SonarQube, NDepend, Architecture Analyzer) accelerate this dramatically. Output is a 90-day, 180-day, and 12-month modernization roadmap with effort estimates, risk tiers, and prioritised quick wins that fund the longer migration.
Decomposing a monolith correctly requires understanding bounded contexts before drawing service lines — domain-driven design applied to the existing business logic, not arbitrary splits by technical layer. We identify high-change-frequency domains (best decomposed first), low-coupling modules (safe to extract), and shared-kernel components (which stay shared). Strangler fig routing at the reverse proxy layer ensures live traffic is migrated incrementally without service disruption.
The highest-ROI modernization move is often not replacing the application, but embedding AI capabilities into the modernised version: intelligent search (semantic over keyword), AI summarisation for long-form content users navigate, copilot sidebars grounded on domain knowledge, anomaly detection on existing data streams, and document processing pipelines that replace manual data entry. Azure OpenAI, Semantic Kernel, and Azure AI Services integrate directly via REST — no platform replacement required.
Legacy Oracle, SQL Server 2008, DB2, and on-premises databases carry schema designs that predate cloud patterns — no soft-delete, no event sourcing, no audit trail, no multi-tenancy. We modernise incrementally: CQRS read models extracted first (no schema change to the write side), followed by schema refactoring behind API boundaries, and migration to Azure SQL, PostgreSQL Flexible Server, Cosmos DB, or Fabric depending on read/write patterns.
WinForms, WebForms, MFC, Delphi, Classic ASP, and early Angular 1.x frontends are the most visible part of technical debt — and the hardest to staff. We extract the business logic from the UI layer (domain services behind API contracts), then rebuild the UI in React, Blazor, or Next.js with modern design systems. Users get a transformed experience; the business keeps its proven domain logic. AI assistants embedded in the new UI from day one.
Legacy applications survive on tribal knowledge, manual deployments, absent test suites, and shared staging environments that nobody dares change. Modernisation without DevOps transformation just makes a modern application that's deployed the same slow, fragile way. We build the CI/CD pipeline, test automation pyramid, infrastructure as code, and observability stack alongside the application modernisation — so the new capability ships safely and continuously.
Modernisation patterns
Every pattern here keeps the legacy system live and serving users throughout the migration — traffic routed incrementally, value delivered every sprint.
Route traffic from legacy to new services incrementally — legacy stays live throughout, no big-bang cut-over required.
Introduce an abstraction layer over the legacy component, route through it, then swap the implementation without changing callers.
Translate between the legacy data model and the new domain model at a boundary — protect the new system from legacy schema decisions.
Emit domain events from legacy system at the data layer (CDC / DB triggers) to feed new event-driven services without changing legacy code.
Extract the database tables owned by a decomposed service — starting with read-only replicas, then full ownership after CQRS read models are stable.
Attach AI capabilities (semantic search, summarisation, document processing) as a sidecar API alongside the legacy system — zero changes to the core app required.
Delivery approach
Five stages designed so users see value in sprint 1, not at programme end — and so AI capabilities are embedded in the modernised surface from the first release.
Week 1–2: AI-assisted codebase analysis — static analysis tools plus Azure OpenAI code summarisation to document undocumented systems. Business capability mapping. Integration dependency graph. Technical debt hotspot identification. Output: modernisation roadmap with effort tiers, risk classification, and prioritised quick wins.
Week 2–3: domain-driven bounded context mapping applied to the legacy system. Strangler fig seam identification. Anti-corruption layer design for legacy-to-modern translation boundaries. Database decomposition strategy (CQRS read model extraction sequence). AI integration points defined — semantic search, copilot features, document processing.
Weeks 3–10: first bounded context extracted using the agreed pattern. Strangler fig routing at reverse proxy. API contract defined and frozen. Legacy system still live for all other domains. CI/CD pipeline built in this sprint — not retrofitted later. Test coverage for the extracted domain from day one. First user-visible capability shipped.
Weeks 6–14: AI capabilities embedded in the modernised surface — semantic search, copilot sidebar, document intelligence. Legacy UI screens replaced progressively (feature-flagged, rolled out by user group or geography). Design system implemented. Accessibility audit. New and legacy surfaces consuming the same API layer throughout the transition.
Months 3–12: remaining bounded contexts migrated to the agreed sequence. Database ownership transferred service by service after CQRS read models are stable. DORA metrics tracked and improved. Architecture Decision Records and runbooks completed. Knowledge transfer sessions with internal engineers. Legacy system decommission plan and timeline agreed.
Client outcomes
Four legacy applications transformed using incremental patterns — every one live-serving users throughout the migration, with AI capabilities embedded in the modernised result.
The Challenge
Global insurance group with a 22-year-old Java EE 5 policy administration monolith running on WebLogic — 1.4 million lines of code, 240 database tables, 18-month deployment cycles due to manual test and release process, and a product team unable to launch new insurance products without 9-month lead time. Microsoft Azure AI Services integration was impossible without a 3-year replacement project.
What We Delivered
Strangler fig decomposition: product catalogue microservice extracted first (highest change frequency, lowest coupling), exposing a REST API that both the legacy UI and a new React portal consumed in parallel. Azure OpenAI AI-powered underwriting assistant sidecarred alongside the legacy system — reading policy data via read-only API, returning structured risk assessments. CI/CD pipeline reduced deployment cycle from 18 months to 2 weeks. Database CQRS read model extracted for the reporting domain.
Global insurance group with a 22-year-old Java EE 5 policy administration monolith running on WebLogic — 1.4 million lines of code, 240 database tables, 18-month deployment cycles due to manual test and release process, and a product team unable to launch new insurance products without 9-month lead time. Microsoft Azure AI Services integration was impossible without a 3-year replacement project.
NHS Trust with a Delphi 7 patient administration system built in 2001 — the original vendor had dissolved, the two remaining internal engineers who knew Delphi were 58 and 61 years old, the system had no API surface, and the Trust needed FHIR R4 compliance for NHS Spine integration within 18 months or face a mandated replacement costing £8M+.
Multichannel retailer with a 2005 Classic ASP order management system — 180,000 lines of VBScript, SQL Server 2005, no source control, deployed via FTP by one contractor who'd been doing it since 2006. Business required real-time inventory across 140 stores, mobile app integration, and personalised AI recommendations. None of these were possible on the existing stack.
Global automotive parts manufacturer with 14 bespoke SAP extensions built in ABAP between 2003 and 2015 — none documented, two written by consultants who were no longer contactable, all tightly coupled to SAP GUI screens that the business was migrating away from. SAP S/4HANA migration blocked by the custom extension debt.
of enterprise applications still run on pre-cloud-native platforms — carrying the compound technical debt of decades of feature additions, integration workarounds, and abandoned modernisation attempts that never finished.
annual enterprise IT spend on legacy maintenance globally — money that could be funding AI capabilities, user experience improvements, and competitive differentiation instead of keeping 20-year-old systems alive.
risk reduction from strangler-fig incremental modernisation vs. big-bang rewrites — industry data from successful migrations consistently shows incremental patterns succeed where wholesale replacement fails.
to document a 500,000-line undocumented legacy codebase with AI-assisted analysis — vs. 6 months manually, reducing the assessment phase that used to block modernisation before it began.
Insights from real-world engineering, cloud, and AI leaders - helping you make better decisions, faster.
Technology StrategyEvery dollar spent on technology should contribute to your business growth. Here are the strategies NCompas recommends to maximize your technology ROI.
Start with a 2-week AI-assisted legacy assessment — we'll document what you have, identify the strangler-fig seams, and give you a prioritised modernisation roadmap with effort estimates and quick wins that deliver value in the first 90 days.