Most insurers can tell you exactly which system they're afraid to touch. It might be a COBOL policy system on a mainframe, or a rating engine on IBM i (AS/400) that only two people understand. Or it's a claims platform from the early 2000s, held together with batch jobs and spreadsheets.
These systems still work. They issue policies, rate risks, pay claims and produce regulatory reports every day. But every new product, state filing, portal or AI project has to go through them and each change takes longer and costs more than it should.
Insurance legacy system modernization means moving those systems to a modern architecture without stopping the business. Policies, premiums, reserves and regulatory reports stay correct while you change what sits underneath.
This guide shows how to tell whether it's time and compares the main modernization options. It also covers safe data migration, where AI helps, what regulators expect, and how to plan the work in stages.
Quick answer: Insurance legacy system modernization usually works best in stages. Start by wrapping the legacy core with APIs so new portals, apps and AI can use it. Then move one product line, system or function at a time to a modern platform, migrating and reconciling data at each step, until the old system can be retired.
Key takeaways
- A full "big bang" replacement is the riskiest option. Most insurers do better with a staged approach.
- An API layer around the legacy core gives you modern portals, apps and AI quickly, while you plan the deeper change.
- Data migration and reconciliation are the hardest part. Premiums, reserves, policy history and open claims must match to the cent.
- Business rules hidden in old code, such as rating and underwriting logic, must be found and documented before anything is rewritten.
- AI can speed up code analysis, documentation, testing and data mapping, but people still need to check every result.
What counts as a legacy system in insurance?
In insurance, "legacy" usually means a core system that is hard to change, hard to connect and depends on skills that are becoming scarce. Common examples:
| System | Typical legacy form |
|---|---|
| Policy administration | Mainframe COBOL or IBM i (AS/400) RPG applications, sometimes heavily customized vendor packages |
| Rating and underwriting | Rules coded directly into programs, or spread across spreadsheets and desktop tools |
| Claims | Older client-server platforms with batch interfaces and limited APIs |
| Billing and payments | Separate systems reconciled through nightly files |
| Agency and broker systems | Old agency management software, Access databases or shared spreadsheets |
| Reporting | Data extracts and hand-built reports for statutory and management reporting |
A system isn't legacy because it's old. It's legacy when it stops you doing things the business needs.
Why insurers are modernizing now
- Knowledge is retiring. The people who wrote or know the system best are leaving, and few new developers learn COBOL or RPG.
- Products take too long to launch. A new coverage, rating change or state filing can take months because every change needs code in the core.
- Customers and agents expect digital service. Online quoting, self-service portals and mobile apps need real-time access to policy and claims data.
- AI needs clean, accessible data. Claims assistants, underwriting tools and service agents can't work well on data locked in batch files.
- Regulatory and security demands keep growing. Older systems make it harder to meet data security, privacy and audit expectations.
- Change is expensive. When a small change takes weeks of specialist work, the real cost of keeping the system goes far beyond its license or hosting fees.
Signs it's time to modernize
- A simple product or rate change takes months.
- Only one or two people can safely change the core system.
- Portals and apps show stale data because they rely on overnight files.
- Staff rekey data between policy, billing and claims systems.
- You can't answer basic questions about your book of business without a custom report.
- Your vendor has announced the end of support, or you're several major versions behind.
- Security reviews keep raising issues you can't fix without major work.
- New AI or digital projects keep stalling at "we can't get the data out."
If three or more of these apply, it's worth assessing your options now rather than waiting for a failure to force a rushed decision.
Free modernization readiness review
Tell us which core system holds you back. In a 30-minute call with our CTO, we'll review it with you, outline which of the 6 options fits and suggest a low-risk first stage. See our insurance software services

Your modernization options
There's no single right answer. Most insurers combine several of these, system by system.
| Option | What it means | Best when | Main risk |
|---|---|---|---|
| Wrap with APIs | Keep the legacy core and build an API layer around it | You need portals, apps or AI soon; the core still works | The core's limits remain; it's a step, not an end state |
| Rehost | Move the application to new infrastructure or cloud with little code change | Hardware or data center costs are the main problem | Same code, same change problems |
| Replatform | Move to a modern runtime or database with limited changes | The code is sound but the platform is the constraint | Hidden dependencies surface during the move |
| Refactor or rebuild in modules | Rewrite the system piece by piece in a modern architecture | You have unique products or processes that packages don't fit | Needs strong rules discovery and testing |
| Replace with a core suite | Move to a commercial platform such as Guidewire, Duck Creek, Majesco or Sapiens | Your products fit the package and you want vendor-supported upgrades | Long, costly programs; heavy configuration still needed |
| Hybrid | Buy a core suite and build custom pieces around it | Most mid-size and large insurers | Integration work grows with each piece |
We explain the build-versus-buy decision in detail in our guide on custom insurance software: when to build, when to buy and how to combine both and modernization approaches in general in our legacy software modernization guide.
Why a staged approach usually wins
A big-bang replacement moves every product, policy and process to a new system on one date. When it works, it's fast. When it doesn't, it can disrupt billing, claims payments and regulatory reporting all at once.
A staged approach, often called the strangler pattern, replaces the old system gradually:
- Wrap the core. Build an API layer so new applications talk to the API, not directly to the legacy system.
- Route new work to the new platform. For example, write new business for one product line on the new system.
- Convert existing policies at renewal. Move each policy when it renews, instead of converting the whole book on one day.
- Run off the old book. Let the remaining policies expire or convert, and close remaining claims, on the legacy system.
- Retire the legacy system once nothing depends on it, keeping archived data accessible for audits and claims.
The API layer makes each step safer, because portals, apps and partners don't need to know which system is answering.
Data migration: the hardest part
Ask anyone who has done it: the code is rarely what sinks an insurance modernization program. The data is.
What has to move
- policies, endorsements and full policy history
- customers, insureds, agents and producers
- premiums, billing history, payments and balances
- open and closed claims, reserves and payments
- documents, notes and correspondence
- product definitions, rates and rules
How to migrate safely
- Profile the data first. Find duplicates, missing values, invalid codes and records that break the rules, before you design the mapping.
- Map fields and meanings. The same field can mean different things in different systems or eras. Document every mapping and every transformation. Industry data standards such as ACORD can help agree on common definitions.
- Migrate in trial runs. Run full test migrations several times before the real one, fixing issues each time.
- Reconcile everything that matters financially. Policy counts, written and earned premium, balances, reserves and claim payments must match between old and new systems, by product and state.
- Run in parallel. For critical processes such as rating, billing and statutory reporting, run old and new side by side and compare results before you switch.
- Keep the history accessible. Claims and audits can reach back years. Plan how archived data will be searched once the old system is gone.
Our guide to data migration best practices covers the general method in more depth.
Finding the business rules hidden in old code
In many legacy insurance systems, the most valuable asset isn't the data. It's the logic: how a premium is calculated in each state, which underwriting rules apply, how a discount interacts with a surcharge, when a renewal is offered.
That logic is often buried in thousands of lines of code, with little documentation. Before you rewrite or replace anything, you need to:
- extract and document rating, underwriting, billing and claims rules
- confirm each rule with underwriting, actuarial, product and compliance teams
- capture the test cases that prove the new system produces the same results
- note which rules are obsolete and can be retired
This matters for compliance too. Rates and forms are filed with state regulators, so the new system must produce the filed rates. Running the same policies through both systems and comparing premiums line by line is the most reliable way to prove it.
Where AI helps in insurance modernization
AI won't modernize a system by itself, but it can take a lot of time out of the work.
- Reading and explaining old code. AI tools can summarize what a COBOL or RPG program does, trace where a field is used and draft documentation. Engineers and business experts must verify the results.
- Discovering rules. AI can help extract candidate rating and underwriting rules from code and documents into readable tables for experts to confirm.
- Generating tests. AI can propose test cases from real policies and rules, which helps prove the new system matches the old one.
- Suggesting data mappings. AI can suggest how fields map between old and new schemas, flagging ones that need a human decision.
- Adding AI on top of the legacy core. Once an API layer is in place, you can add AI assistants for claims, service and underwriting without waiting for the full modernization.
For example, an AI claims assistant can sit on top of a wrapped legacy claims system and answer coverage questions with citations from the policy documents. Our AI claims processing guide explains how that works, and our AI integration services cover connecting AI to systems you already run.
Can you build modern apps on a legacy core?
Yes, and it's often the fastest way to show value early. With an API layer in front of the core, you can build:
- policyholder portals and mobile apps for quotes, payments, ID cards and claims
- agent and broker portals with real-time policy status
- field apps for adjusters with photo capture, document scanning and offline sync
- online quoting journeys that call the rating engine in real time
The API layer handles security, caching and translation, so the legacy system isn't overloaded and the apps don't depend on its quirks. When you later replace part of the core, the apps keep working.
Real example: SelectQuote. We contributed to SelectQuote's customer-facing digital insurance journey, which helps customers compare and choose coverage online. Our work covered the frontend architecture in React and Next.js, with server-rendered pages that load fast and can be found in search, plus Node.js services on AWS Lambda for quoting and data access, so quoting capacity scales with demand. Read the SelectQuote case study. For more on building insurance apps, see our insurance app development guide.
Keeping regulators, auditors and security teams comfortable
Modernization changes how you meet your obligations, not the obligations themselves.
- Rates and forms: the new system must produce filed rates and use approved forms. Prove it with parallel runs before switching.
- Statutory and regulatory reporting: reconcile reports from the old and new systems before relying on the new ones.
- Data security: many states have adopted insurance data security laws based on the NAIC model, which require a written security program, risk assessment and incident response. Build these into the new architecture from the start.
- Record retention: keep policy, claims and financial records accessible for the periods your states require, even after the old system is retired.
- Audit trail: log who changed what, when and why, in both the migration and the new system.
- Vendors: if a cloud provider or software vendor handles your data, include them in your vendor oversight program.
A staged modernization roadmap
We run insurance modernization work in six phases. The same phases appear on our insurance software development services page.
- Discover. Map systems, data flows, interfaces, rules, users and pain points. Agree on business goals and what "done" means.
- Architect. Choose the target architecture and the option for each system: wrap, replatform, rebuild or replace. Design the API layer and the data migration approach.
- Build. Build the API layer first, then the first new module or integration, with automated tests from real policies and claims.
- Validate. Run trial migrations, reconcile financials, run old and new in parallel, and test security and performance.
- Deploy. Switch one product line, state or function at a time, with a rollback plan for each step.
- Evolve. Retire legacy pieces as they empty, add AI and digital services on the new foundation, and keep improving.
If you're at the very start, a short discovery workshop is the fastest way to turn a vague modernization goal into a plan with clear first steps.
How to choose a modernization partner
Look for a team that:
- has worked with insurance data, products and regulation, not just general software
- can read and work with your legacy technology as well as modern stacks
- proposes a staged plan with early, visible results, not a single long program
- treats data migration and reconciliation as a core workstream, not an afterthought
- builds automated tests and parallel runs into the plan
- explains clearly what they'll deliver at each stage, and what it costs
Our guide on how to choose an insurance software development company has a full checklist.
What does insurance legacy modernization cost?
Costs vary widely. The main drivers are:
- the number of systems, products and states in scope
- the option chosen for each system, from wrapping to full replacement
- data volume, age and quality
- how much business logic is undocumented
- the number of integrations with partners, vendors and internal systems
- testing, parallel running and regulatory validation
- licensing, if you buy a core platform
A staged plan spreads the cost and lets you prove value early. Wrapping the core with APIs and launching one new portal or AI use case is usually a much smaller first investment than replacing a whole policy system.
Illustrative example: an MGA on an AS/400 policy system
A managing general agent writes specialty commercial lines on a policy and rating system built on IBM i (AS/400) many years ago. Its brokers want online quoting, its team rekeys data into a separate claims system, and the two developers who know the RPG code are planning to retire.
A staged plan might look like this:
- Months 1 to 3: discovery, documentation of rating and underwriting rules with AI-assisted code analysis checked by the developers and underwriters, and an API layer for quoting and policy lookup.
- Months 4 to 6: a broker portal for quotes and policy status, built on the API layer, plus a sync between the policy and claims systems.
- After that: move new business for one product line to a modern policy platform, convert renewals as they come up, and run off the rest of the book on the old system.
At each stage, the MGA reconciles premiums and policy counts, and runs quotes through both systems to confirm the rates match.
Ready to plan your modernization?
Tell us which system holds you back the most. We'll map it, show you the options, and plan a first stage that delivers something useful within months, without putting your book of business at risk.
Explore our insurance software development services or talk to our team.



