Project Overview
| Client Industry | Insurance (Life and Annuity) |
| Business Type | Mid-size life insurance carrier managing ~180,000 active policies |
| Project Duration | 30 weeks |
| AI Service Provided | Legacy Application Modernization |
| Technologies Used | React, TypeScript, Java (Spring Boot), COBOL (legacy source), PostgreSQL, DB2 (legacy source), AWS (ECS, RDS, S3), Terraform, MuleSoft |
The Client Challenge
The client’s core policy administration system had been running on a mainframe with COBOL applications and a DB2 database since the early 1990s, handling policy issuance, premium processing, and claims for the entire book of business.
The compounding risks and limitations:
- The engineers who originally built and maintained the COBOL system had largely retired, and the small remaining team with mainframe expertise represented a serious single-point-of-failure risk for a system processing active insurance policies.
- Adding new product features or adjusting to changing state insurance regulations required mainframe development that took months, compared to what modern development practices could achieve in weeks.
- The system had no modern API layer, making it effectively impossible to offer the self-service customer and agent portals that had become table stakes competitively in the life insurance industry.
- Batch processing windows for nightly premium and policy updates had grown so long that they increasingly ran into business hours, creating data consistency risks and limiting when other maintenance could occur.
- Mainframe hosting and licensing costs continued rising annually, while the system’s ability to support new business requirements continued declining.
- Regulatory examiners had begun asking pointed questions about the company’s technology risk and business continuity planning given the aging, poorly documented system a genuine business risk, not just a technical inconvenience.
A full rewrite carried enormous risk given the system managed active policies and real policyholder money; any migration error could mean incorrect premium calculations or policy data corruption affecting real customers.
Our Solution
Air Brite Labs led a phased legacy modernization, migrating the policy administration system from COBOL/DB2 to a modern Java-based architecture using the strangler fig pattern building new capabilities and progressively migrating existing functionality module by module, with rigorous parallel-run validation at every stage given the financial stakes involved.
Key outcomes delivered through the modernization:
- Modern API layer — a new Spring Boot-based service layer now exposes policy, premium, and claims functionality through well-defined APIs, finally making self-service portals and third-party integrations feasible.
- Faster batch processing — nightly premium and policy processing windows were reduced substantially, eliminating the risk of batch jobs running into business hours.
- Reduced key-person risk — the modern Java codebase follows current engineering practices with proper documentation and test coverage, significantly reducing the company’s exposure to the retiring mainframe expertise problem.
- Faster feature and regulatory response time — new product features and state regulatory changes that previously took months in the mainframe environment can now be implemented in weeks.
- Preserved data integrity throughout migration — every policy and premium calculation was validated against the legacy system’s output before cutover, with zero data integrity issues throughout the phased migration.
- Improved regulatory standing — the modernization directly addressed the technology risk concerns regulatory examiners had raised, strengthening the company’s compliance position.
Technical Approach
Migration Pattern: Applied the strangler fig pattern with an integration layer built using MuleSoft, initially routing requests to the legacy COBOL system while new Java-based modules were built and validated, then progressively shifting functionality to the modern system module by module (policy inquiry, premium calculation, claims processing, policy issuance).
Business Logic Extraction: A significant portion of the project involved carefully extracting and documenting business logic embedded in decades-old COBOL code including premium calculation rules, policy rider logic, and state-specific regulatory variations working closely with the remaining mainframe-knowledgeable staff to ensure nothing was lost or misinterpreted in translation.
Modern Backend: Built on Java with Spring Boot, chosen specifically for its maturity in enterprise financial services contexts and strong ecosystem support for the kind of rigorous testing and auditability insurance systems require.
Data Migration: Policy and premium data was migrated from DB2 to PostgreSQL in phases, using a parallel-run validation approach where every migrated policy’s calculated values were compared against the legacy system’s output for an extended validation period before that policy’s processing was cut over to the new system.
Frontend Modernization: Built new React and TypeScript interfaces for internal policy administration staff and the foundation for future customer and agent self-service portals, replacing terminal-based mainframe screens.
Integration Layer: MuleSoft served as the integration backbone throughout the migration, managing the routing logic between legacy and modern systems during the transition period and remaining in place afterward to support future third-party integrations (reinsurance partners, agent management systems).
Infrastructure: The modern system runs on AWS ECS with infrastructure defined in Terraform, while the legacy mainframe environment remained operational and untouched until each specific module’s migration was fully validated and cut over.
Validation Rigor: Given the financial and regulatory stakes, every migrated calculation module went through an extended parallel-run period often several full processing cycles comparing legacy and modern system outputs line by line before that module’s legacy counterpart was retired.
Implementation Process
- Discovery & Requirement Analysis (Weeks 1–8): Conducted an extensive audit of the COBOL codebase and DB2 data model, working with the remaining mainframe-experienced staff to extract and document business logic that existed only in code — a substantial and necessarily careful undertaking given the financial calculations involved.
- Prototype / PoC (Weeks 9–12): Built the MuleSoft integration layer and migrated the lowest-risk module (policy inquiry, a read-only function) first to validate the migration and parallel-run validation approach.
- Development (Weeks 13–24): Sequentially migrated premium calculation, claims processing, and policy issuance modules, with each module rebuilt in the modern Java stack and validated extensively before cutover.
- Integration (Weeks 25–26): Built the modern React-based internal administration interface and completed MuleSoft integration configuration for the fully modernized system.
- Testing (Weeks 27–28): Extended parallel-run validation across multiple full premium processing cycles for all migrated modules, with any discrepancies investigated and resolved before proceeding.
- Deployment (Week 29): Completed final cutover for the last remaining legacy modules, with the mainframe environment decommissioned after a defined post-cutover monitoring period.
- Optimization (Week 30 and ongoing): Tuned batch processing performance and began planning the customer and agent self-service portal work the new API layer now makes possible.
Key Features Delivered
- Modern Java/Spring Boot policy administration system replacing 30-year-old COBOL/DB2 infrastructure
- API layer enabling future self-service portals and third-party integrations
- Significantly reduced batch processing windows for nightly premium and policy updates
- Modern, documented, test-covered codebase reducing key-person mainframe risk
- MuleSoft-based integration architecture supporting future partner and agent system connections
- Rigorously validated data migration with zero data integrity issues throughout the transition
- New internal administration interface replacing legacy terminal-based screens
Business Results
- Nightly batch processing time was reduced substantially, eliminating the risk of processing extending into business hours
- New product feature and regulatory change implementation time dropped from months to weeks
- Zero data integrity issues occurred throughout the entire phased migration, validated through extensive parallel-run testing across all migrated modules
- Mainframe licensing and hosting costs were eliminated following full decommissioning, replacing them with cloud infrastructure costs that scale with actual usage
- The company’s regulatory standing improved, with the modernization directly addressing technology risk concerns previously raised by examiners
- The new API layer positioned the company to begin building long-requested customer and agent self-service portals, previously infeasible on the legacy architecture
Technology Stack
| Layer | Technology |
|---|---|
| Frontend | React, TypeScript |
| Backend (Modern) | Java (Spring Boot) |
| Backend (Legacy, decommissioned) | COBOL |
| Database (Modern) | PostgreSQL |
| Database (Legacy, decommissioned) | DB2 |
| Integration Layer | MuleSoft |
| Infrastructure as Code | Terraform |
| Cloud Infrastructure | AWS ECS, RDS, S3 |
Why the Solution Worked
The modernization succeeded because it treated the financial and regulatory stakes of an insurance policy system with the rigor they demanded, rather than applying a generic legacy migration playbook. The extended parallel-run validation approach comparing legacy and modern system outputs across multiple full processing cycles before any cutover was slower than a faster, riskier migration approach, but it was the right trade-off for a system managing real policyholder money and regulatory scrutiny.
Investing heavily in extracting and documenting business logic from the COBOL codebase, working directly with the remaining mainframe-experienced staff before they too retired, was equally critical. That knowledge transfer, done carefully and deliberately, is what prevented the kind of silent logic loss that causes serious problems in financial systems migrations.
Future Scalability
The modernized platform is built to support the company’s continued evolution, including:
- Building the customer and agent self-service portals that the new API layer now makes possible, a capability entirely unavailable on the legacy mainframe system
- Extending MuleSoft integrations to reinsurance partners and third-party agent management platforms
- Adding new insurance products more rapidly using the modern, modular Java architecture
- Continuing to strengthen the company’s regulatory technology risk position as further modernization initiatives build on this foundation
Because the legacy mainframe was fully decommissioned rather than left running alongside the modern system indefinitely, the company now has one current, well-documented architecture to build future capabilities on rather than maintaining two parallel systems.
Final Outcome
A 30-year-old mainframe system carrying real business continuity and regulatory risk was modernized into a fast, well-documented, API-enabled platform with zero data integrity issues across 180,000 active policies throughout the transition. What had become a mounting technology and compliance liability is now a modern foundation the insurer can build new products and customer experiences on.


