🏦 Lending Application Modernization Roadmap From: EXTJS + EJBs + Oracle → Microservices + Cloud-native + API-first

Anand Nerurkar
Aug 20
2 min read

1. Current State Assessment

UI Layer: EXTJS monolithic UI (tight coupling with server-side rendering).
Business Logic: Stateless EJBs & Entity Beans, tightly coupled with Oracle schema.
Integration: Point-to-point, no service boundaries, synchronous communication.
Pain Points:
- Slow release cycles
- Hard to scale individual modules (e.g., KYC vs Loan Evaluation)
- Technology obsolescence (EJB, EXTJS)
- Difficult cloud migration

2. CAST Analysis (Static Code Insights)

CAST provides:

Code complexity & hotspots → Identify highly coupled modules.
Transaction flow mapping → End-to-end flow for Loan Origination, KYC, Disbursement.
Data model dependencies → Oracle schema tightly coupled with Entity Beans.
Dead code & technical debt → Identify candidates for retirement vs refactor.

👉 Output: Microservice decomposition candidates + technical debt heatmap.

3. vFunction Analysis (Runtime & Modernization Insights)

vFunction provides:

Domain-driven service candidates (e.g., KYC Service, Loan Evaluation Service, Credit Scoring Service).
Event boundaries → Which modules can communicate asynchronously.
Cloud-readiness scoring → Highlighting refactor vs rewrite.
Strangler pattern opportunity → Which flows to extract incrementally.

👉 Output: Modernization blueprint with bounded contexts + service dependency graph.

4. Target State (Modern Architecture)

Frontend Modernization

Replace EXTJS → Angular/React micro-frontends.
API-first approach: UI interacts only via REST/gRPC APIs.

Backend Modernization

EJB decomposition → Spring Boot microservices.
Entity Beans → JPA/Hibernate + DTOs.
Services:
- Customer/KYC Service
- Loan Origination Service
- Credit Score Service
- Loan Evaluation Service
- Payment/Disbursement Service
Event-driven messaging → Kafka for async flows (e.g., Loan-Initiated → KYC-Completed → Loan-Evaluated).

Database Modernization

Monolithic Oracle schema → Schema-per-service (logical partitioning).
Introduce CQRS + materialized views for reporting.
Use Azure/AWS/GCP managed DBs (Postgres, CosmosDB, DynamoDB).

Platform & DevOps

Containerize with Docker + Kubernetes (AKS/EKS/GKE).
API Management (Azure APIM / Kong / Istio Ingress).
Service Mesh: Istio for observability, routing, canary, blue-green.
CI/CD: GitHub Actions / Azure DevOps Pipelines.
Logging & Monitoring: ELK / Prometheus / Grafana.

5. Migration Strategy (Phased Roadmap)

Phase 1: Assessment & Planning

CAST analysis → baseline complexity, dependency heatmap.
vFunction analysis → define service boundaries.
Business capability mapping → align with lending journey (Onboarding → KYC → Loan → Repayment).

Phase 2: Strangler Pattern Start

Expose legacy EJB functionality as APIs (API Gateway façade).
Introduce new React/Angular UI consuming APIs.
Extract non-critical modules first (e.g., Credit Score Service).

Phase 3: Core Lending Refactor

Migrate Loan Origination & Evaluation modules into microservices.
Split Oracle schema → dedicated service DBs.
Introduce Kafka for event-driven flow.

Phase 4: Full Modernization & Optimization

Sunset EXTJS completely → full micro-frontend adoption.
Retire EJBs → all Spring Boot services.
Implement Istio for traffic management (canary, blue-green).
Adopt SRE practices (SLIs, SLOs, Error Budgets).

6. Risk & Mitigation

Risk	Mitigation
Business disruption during migration	Strangler fig pattern + API façade
Data integrity across multiple services	Event-driven consistency + Saga pattern
Resistance to change (developers/ops)	Training, parallel run, phased rollout
Cloud cost overruns	FinOps, auto-scaling, right-sizing
Legacy vendor lock-in	Open-source stack + cloud-agnostic design

✅ End Result:A cloud-native, event-driven, microservices-based lending platform with modular frontend, API-first design, schema-per-service databases, CI/CD automation, and strong observability — enabling faster releases, scalability, and modernization.