Legacy Modernization RoadMap woth CAST &VFunction

1. Current State Assessment

• UI: EXTJS (legacy JavaScript framework, tightly coupled with backend APIs).

• Backend: Java EE (Stateless Session EJBs, Entity Beans).

• Database: Oracle (monolithic schema, tightly coupled to entity beans).

• Challenges:

  • Strong coupling between business logic and persistence.

  • No clear API boundaries.

  • Hard to scale specific modules (e.g., Loan Origination, KYC, Collections).

  • Limited CI/CD automation.

  • High cost of change → regression impact across modules.

2. CAST Analysis (Discovery & Assessment)

CAST helps you analyze the monolith codebase and provides actionable insights:

• Architecture Blueprints: Identify dependencies between EJBs, Entity Beans, UI layers, and Oracle DB.

• Code Complexity & Technical Debt: Pinpoint high-risk modules (e.g., Loan Calculator, KYC Service).

• Service Candidate Identification: Using CAST’s Application Intelligence Platform (AIP), discover natural seams for service extraction.

  • Example: Loan Origination logic isolated from KYC/Collections.

• Data Layer Dependencies: Identify database tables heavily coupled with entity beans.

• Quality Gates: Define modernization KPIs (cyclomatic complexity, maintainability index, modularity).

👉 Output: CAST generates a service decomposition map + modernization insights.

3. vFunction Refactoring (Domain-driven Extraction)

vFunction automates monolith decomposition into microservices.Steps:

1. Instrumentation & Runtime Analysis

   • Attach vFunction agent to legacy app.

   • Collect runtime call graphs, dependencies, usage patterns.

2. Domain Clustering

   • vFunction groups related classes/methods into domain-based clusters (Loan Processing, Customer Profile, Collections, Risk Management).

   • Align with business capabilities → Capability Map.

3. Service Candidates & APIs

   • vFunction suggests candidate services:

     • Customer Service (Profile, KYC)

     • Loan Origination Service (Application, Eligibility Check)

     • Risk & Credit Scoring Service

     • Collections Service

     • Notification Service

4. Strangler Fig Approach

   • Incrementally carve out services from monolith.

   • Replace EJB calls with REST APIs or gRPC endpoints.

   • Use API Gateway (e.g., Kong, Istio, or Azure API Management) to route traffic.

4. Target State Architecture

Frontend Modernization

• Replace EXTJS with Angular/React micro-frontend.

• Use API Gateway to connect frontend with microservices.

Microservices Layer

• Each microservice = Spring Boot / Quarkus + REST/gRPC.

• Stateless, lightweight, containerized.

• Decoupled from Oracle DB → migrate gradually to Polyglot Persistence (PostgreSQL, NoSQL, Event Store).

Database Strategy

• Phase 1: Keep Oracle as system of record (shared DB schema).

• Phase 2: Apply Database Decomposition:

  • Loan Service → PostgreSQL

  • KYC Service → MongoDB

  • Risk Analytics → Event Store + Kafka

Infrastructure

• Containerization: Docker + Kubernetes (AKS/EKS/GKE).

• Service Mesh: Istio for service discovery, observability, traffic routing (supports Canary + Blue/Green).

• CI/CD: Azure DevOps / GitHub Actions.

5. Roadmap Phases

Phase 1 – Assessment & Strategy (2–3 months)

• Run CAST to analyze codebase.

• Run vFunction to identify service boundaries.

• Define modernization KPIs.

• Build Capability Map & Service Decomposition Blueprint.

Phase 2 – Pilot Service Extraction (3–6 months)

• Use vFunction to extract Customer Profile & KYC Service.

• Deploy first microservice in production (Strangler Fig).

• Introduce API Gateway + CI/CD pipeline.

Phase 3 – Incremental Modernization (6–12 months)

• Extract Loan Origination, Risk & Credit Scoring, Collections.

• Migrate UI to Angular/React.

• Introduce Event-driven Architecture (Kafka for loan events).

Phase 4 – Database Modernization (12–18 months)

• Gradually break monolithic Oracle schema.

• Assign dedicated databases per service (Polyglot).

• Implement Data Mesh principles if required.

Phase 5 – Optimization & Cloud-native (18+ months)

• Optimize services for scalability (autoscaling, caching).

• Introduce AI/GenAI agents for Loan Recommendation & Fraud Detection.

• Full migration to cloud-native architecture.

6. Risks & Mitigation

• Risk: High DB coupling with Entity Beans.

  • ✅ Mitigation: Introduce Data Access microservices (facade) before migration.

• Risk: Business disruption during cutover.

  • ✅ Mitigation: Strangler Fig + Canary Releases.

• Risk: Developer skill gaps.

  • ✅ Mitigation: Training in Spring Boot, Kubernetes, CI/CD.

• Risk: Legacy code complexity.

  • ✅ Mitigation: CAST insights + vFunction automation reduce manual effort.

✅ End Result:

• From legacy EXTJS + EJB monolith → to domain-driven, event-driven microservices with CAST insights for code modernization and vFunction for automated service extraction.

• Cloud-native, scalable, resilient lending platform.