A ten-year leak in a claims platform, found and fixed on schedule

A US insurer's claims platform had been leaking money for ten years. Its payment rules lived in COBOL batch jobs, a Java layer added later took claims in, and nobody had written down how the two talked.

Length
16 weeks: map it, stop the leaks, move the first three claim types

Two layers, two decades, no manual

The client. A mid-sized US property and casualty insurer with about 600 staff, running claims on a platform bought from a vendor that stopped active development years ago.

The core adjudication rules run as COBOL batch jobs. A Java layer added later handles intake and the adjusters' screens. The people who wrote either part have left, and the vendor's manual stops at version 4.

Every month, adjusters work around the same failures by hand: claims stuck between the two layers, duplicate payments caught late, and reserve figures that disagree with the general ledger. Nobody can say what it costs, only that it has been costing for ten years.

How the engineers did it

  1. Read before touching

    Engineers trace every batch job, copybook and Java service with AI-assisted code search, then confirm each finding by running it against a masked copy of production data.

  2. Write the missing manual

    Each mapped path becomes documentation the insurer keeps: what the code does, where money moves, and which rules nobody remembers adding.

  3. Stop the leaks first

    Reproduce the duplicate-payment and stuck-claim bugs as tests, fix them in place, and measure the difference before any migration starts.

  4. Move it one slice at a time

    Lift adjudication rules out of COBOL into tested services behind the existing screens, one claim type at a time, with the old path kept as a fallback.

  5. Every change signed

    Nothing merges without an engineer's review and the claims lead's sign-off, and every release has a rehearsed rollback.

For your engineers

What was built

  • A map of every batch job, copybook and service that moves money
  • Documentation written from the code itself
  • Regression tests that pin today's behaviour before anything changes
  • Adjudication services for the first three claim types
  • A release checklist with review, sign-off and a rehearsed rollback

Stack

COBOL and JCL, Java, AI-assisted code search, regression and contract tests, strangler-fig migration

Length

16 weeks: map it, stop the leaks, move the first three claim types

What changed

MeasureBeforeAfter
Duplicate paymentsfound at month-end reconciliationblocked before payment
Claims stuck between the COBOL and Java layersworked around by hand each weeknone open past 24 hours
Code paths that move money, documentednone after the version 4 manualall of them

What we learned

  • Read the code before proposing a rewrite. The old system knows rules nobody wrote down.
  • Fix the leaks in place first. They pay for the migration.
  • AI speeds up the reading. People decide what ships.

Bring the system nobody wants to touch

The diagnostic maps one corner of it, finds where it leaks, and prices the fix before anyone mentions a rewrite.