Insurance policy admin system modernization: where to start

Why the product logic matters more than the platform

Most insurers that start looking at their policy administration system begin with the wrong question: which platform should we move to? Vendor demos are easy to schedule, and a shortlist feels like progress. But the platform is the part of the project you can change your mind about. The product logic is not.

An older policy admin system holds years of decisions that nobody wrote down in one place: how a premium is rated, which endorsements are allowed on which product, what happens at renewal when a rule changed three years ago for new business but not for existing policies. That logic lives in the code, mostly in COBOL, PL/I, Oracle Forms or aging Java. The people who wrote it have often left. If you pick a target platform before you can describe that logic, you are choosing the destination without knowing what has to be carried there.

What you need to recover first

Before any platform decision, a modernization team needs a working picture of three things.

  • Rating rules. The calculations that turn risk data into a premium, including factors, tables, surcharges, discounts and the order they are applied in. Rating is where small differences cost real money, so it has to be understood exactly, not approximately.
  • Product variants. Older systems rarely have one clean definition per product. They have the base product, regional versions, legacy variants kept alive for existing policyholders, and special cases added for one distribution channel. Each one carries its own rules, and some are only reachable through a particular screen or batch path.
  • The batch cycles around them. Renewals, billing runs, commission calculations, reporting extracts and regulatory feeds usually run outside the online screens. They read and write the same policy data, and they often apply rules that appear nowhere in the user interface.

If any of these three is missing from your plan, the gap tends to show up late, as a premium that does not match or a renewal that behaves differently in the new system.

How to start without guessing

The practical way to begin is to read the existing code and build a map of what it does, before anyone writes new code. That means tracing each rating calculation back to the fields and tables it depends on, listing the product variants that actually exist in the code (as opposed to the ones the product team remembers), and following the batch jobs to see what they change.

Doing this by hand is slow, because the knowledge is spread across many programs and the documentation is usually incomplete or out of date. Replai reads legacy code and builds a structured map of business rules, workflows and dependencies, so your team can ask plain-language questions about the code and trace how a change to one field ripples through the system. Our guide on extracting business rules from COBOL code covers the rule-recovery step in more detail, and data lineage in legacy systems explains how to follow a field from the screen to the table.

A sensible output of this first phase is a plain document the business can review: the rating rules, the list of live product variants, the batch jobs and what each one touches. Underwriters and product owners can check it against what they believe the system does. The disagreements you find at this stage are cheap. The same disagreements found after go-live are not.

Then choose the target and the approach

Once the product logic is recovered, the platform and strategy question gets much easier to answer. You can see how much of the logic is standard and how much is unusual, which tells you whether a packaged policy platform will fit or whether you need to rebuild specific parts. You can also see which parts are unused. Our piece on finding unused code before you migrate is useful here, since there is no reason to carry dead variants into a new system.

From there, the options are the familiar ones, compared in rehost, refactor, rewrite or replace. If you cannot stop the business while you change systems, the strangler fig pattern lets you move one product line at a time. Whichever route you take, plan how you will prove the new system matches the old. Testing a migrated system for behavior parity is far easier when you already have the rules written down to test against.

For the wider picture on timelines and the discovery phase, see what AI-assisted legacy code modernization involves. If you want to talk through your own policy system, you can see how Replai approaches legacy system discovery.

Frequently asked questions

Why shouldn't we pick the target platform first when modernizing a policy admin system?

The platform is the part you can change your mind about, while the product logic in your old code is not. If you choose a destination before you can describe the rating rules, product variants and batch behavior, you do not know what has to be carried over.

What business logic should an insurer recover before modernizing?

Three things: the rating rules that produce a premium, the product variants that exist in the code (including legacy ones kept for existing policyholders), and the batch cycles such as renewals and billing that read and write the same policy data.

Why are batch cycles a risk in policy system modernization?

Batch jobs often run outside the online screens and can apply rules that appear nowhere in the user interface. If they are missed in planning, the gap tends to show up late as a renewal or billing result that differs in the new system.

Where does the business logic in an older policy system actually live?

Mostly in the code itself, written in languages such as COBOL, PL/I, Oracle Forms or older Java. The original developers have often left and the documentation is usually incomplete or out of date.

How does Replai help with the first phase of modernization?

Replai reads existing legacy code and builds a structured map of business rules, workflows and dependencies. Your team can then ask plain-language questions about the code and trace how a change to one field affects the rest of the system.

Can we modernize one product line at a time?

Yes. If the business cannot stop during the change, a staged approach such as the strangler fig pattern lets you move one product line at a time while the rest keeps running.