Legacy Modernization with CAST & VFunction

Legacy to Microservices Modernization Roadmap

Context

• Current state: Legacy Loan Application

  • UI: EXTJS (monolithic frontend, tightly coupled with backend APIs)

  • Business logic: Stateless EJBs, Entity Beans

  • Persistence: Oracle DB (monolithic schema, coupled transactions)

  • Challenges: Rigid deployment cycles, scalability issues, high coupling, difficult maintainability

• Target state:

  • Microservices-based architecture with domain-driven design (DDD)

  • Modern UI (Angular/React/Vue) decoupled via APIs

  • Cloud-native deployment (AKS/EKS/GKE or OpenShift)

  • Event-driven integrations (Kafka, APIs)

  • Resilient database design (polyglot persistence, per-service schema)

Step 1: Application Assessment & Intelligence (CAST)

🔹 CAST Highlight Use:

• Code inventory & complexity analysis: Detect EJB dependencies, Oracle stored procedures, and UI-to-backend coupling.

• Static code analysis: Identify dead code, performance hotspots, and technical debt.

• Architecture insights: Auto-generate dependency maps showing module-to-module and DB dependencies.

• Cloud-readiness assessment: Gaps in scalability, session management, security, and hard-coded configs.

📌 Output: Baseline report of complexity, hotspots, dependencies (UI → EJB → DB), and modernization feasibility.

Step 2: Domain-Driven Decomposition (vFunction)

🔹 vFunction Highlight Use:

• Runtime analysis: Capture live traces of how EJBs, Entity Beans, and Oracle queries interact.

• Service candidates: Use AI to suggest domains (e.g., Loan Origination, Credit Score, Customer Management, Payments).

• Tangle detection: Identify “God Classes” or tightly coupled modules blocking separation.

• Automated refactoring: Convert monolithic code units into microservice-ready modules.

📌 Output: Candidate microservices blueprint with dependency graph and refactoring plan.

Step 3: Modernization Roadmap

🔹 Phase 1: Quick Wins & Strangulation Pattern

• Introduce API Gateway (Kong, Apigee, Azure APIM) in front of monolith.

• Wrap existing EJB services as REST APIs → expose limited functionality without big-bang rewrite.

• Start UI modernization: migrate EXTJS → React/Angular with API-first approach.

🔹 Phase 2: Service Carving (vFunction-guided)

• Break down business domains into candidate microservices:

  1. Customer Service (customer info, KYC)

  2. Loan Origination Service (loan request intake, rules)

  3. Credit Score Service (integration with bureau)

  4. Loan Evaluation Service (eligibility check, risk)

  5. Disbursement Service (fund release, notifications)

  6. Payment Service (repayments, schedules)

• Each service gets its own schema (Oracle → Postgres/NoSQL migration gradually).

🔹 Phase 3: Infrastructure Modernization

• Containerize services → deploy on Kubernetes/Istio.

• Use Istio for traffic routing (canary, blue-green).

• Integrate Kafka for event-driven flows (LoanRequested → KYCCompleted → CreditChecked).

• Use DevOps pipeline (Azure DevOps/Jenkins/GitHub Actions) for CI/CD.

🔹 Phase 4: Full Cloud-Native Target State

• All legacy EJBs retired.

• Services independently scalable, fault-tolerant.

• Observability stack (Prometheus, Grafana, ELK).

• Automated AI-based scaling & retraining for credit/fraud ML models.

• Governance in place: API catalog, standards, compliance (e.g., RBI, GDPR).

Step 4: Risks & Mitigation

Risk	Mitigation
Tight coupling between EJBs & DB schema	vFunction automated untangling, refactor to service schemas
UI rewrite complexity (EXTJS → modern)	Strangler pattern, progressive migration
Data migration risk	Use CDC (Change Data Capture) tools to sync old & new DBs
Skill gap in microservices/cloud	Upskill team + external SMEs
Performance bottlenecks	Early load testing, CAST performance insights

Final Modernization Architecture (Target)

[Frontend] React/Angular

⬇

[API Gateway + BFF Layer]

⬇

[Microservices] Loan, Customer, Credit, Disbursement, Payments (Spring Boot/Quarkus)

⬇

[Data] Polyglot persistence (Postgres, MongoDB, Oracle legacy fallback)

⬇

[Infra] Kubernetes + Istio + Kafka + DevOps

✅ CAST → Assessment & insights✅ vFunction → Automated refactoring & service extraction✅ Strangler pattern → risk-free phased modernization