Shedding legacy models: a Python migration story

We rebuilt a full suite of actuarial valuation models in Python: delivered on time for year‑end, running faster, free from licensing fees, and signed off with zero audit queries. What began as one urgent migration has now become a repeatable approach that we have successfully deployed across multiple clients.

Model migrations often have a reputation for being slow, painful to manage, and costing more than expected. This means that there is a long payback period before the benefits of the new migrated model outweigh the transition costs. But this doesn’t have to be the case. 

Our recent experience demonstrates that, with the right skills, tooling and methodology, a migration can be fast, efficient and transformative. 

Setting the scene 

A client joined Barnett Waddingham (BW) with an established set of actuarial models built on a licensed vendor platform, previously maintained by its in‑house actuarial function. When that function was outsourced to BW, the vendor licence prevented us from using or modifying the existing models. 

This meant one thing: we needed to rebuild the models from scratch. 

We carried out a detailed assessment of several technology options under seven different categories:

Python emerged as the clear choice. It offered the transparency, flexibility and long‑term maintainability the client needed, while also removing significant licensing costs. Furthermore, BW already had the hardware in place to develop and deploy Python based models, and the skills and knowledge to develop Python models.   

The key challenge? The new Python models needed to be fully built, tested, documented and production‑ready within just over three months to support the upcoming year‑end valuation. 

The model features required were wide ranging – it needed to cover a wide range of Life and Critical Illness products, with varied premium structures, expenses, reinsurance, lapses, and multiple output requirements.  

And, as every actuary knows, building the model is only part of the battle – it would still need to be rigorously tested and documented before moving into production. The biggest risk here was that, if the model has not been well built, testing would expose cracks which could take time to correct and cause deadlines to slip away. 

This Gannt chart shows the process we used to design, build, test, and signoff the models in a three month period. 

^{Source: Barnett Waddingham}

Working smarter and harder 

We knew the timelines were tight. To succeed, we combined three strengths: 

1. A blended team with the right expertise 

Our delivery team brought together experienced life actuaries skilled in modelling and migration, alongside a dedicated software developer to support architecture, code orchestration and optimisation. 

This combination ensured both actuarial accuracy and high‑quality engineering, which is essential for long‑term maintainability. 

2. A disciplined, standards‑driven build approach 

Clear coding standards, internal best practices, and consistent structures enabled the team to collaborate efficiently, avoid duplication, and maintain quality across multiple workstreams. 

3. AI‑accelerated development; used safely and effectively 

To meet the aggressive deadlines, we used AI directly from our IDE (integrated development environment)  

This allowed AI to: 

• generate initial code scaffolding;
• speed up repetitive or boilerplate elements;
• help maintain consistency across modules; and
• support actuaries who were not yet Python specialists.

Importantly, to meet our privacy and data control standards, the AI had access only to the codebase, but never to client data.  

AI didn’t replace expertise; it amplified it. And combined with close collaboration and diligent review, it enabled us to deliver the full build, testing and documentation on time. 

So, was it worth it? 

For the client, absolutely. Rebuilding in Python delivered several immediate benefits: 

• Elimination of vendor licensing fees, reducing ongoing costs 
• Faster model run times, freeing up operational capacity 
• Improved governance, with transparent, version‑controlled code 
• Clear audit trails and reproducibility, boosting stakeholder confidence 

Most importantly, the Python model suite was fully tested, fully documented, delivered on time, and used successfully for the year‑end valuation – with zero external audit queries. 

For BW, the project was equally valuable. 

It established a repeatable Python migration process that has now been deployed across five other clients, proving that modernising legacy models need not be a slow or painful journey. 

A better way to migrate 

This project shows what’s possible when actuaries, developers and modern tools come together behind a clear objective. With the right approach, team management, and technology, model migrations can be: 

• efficient;
• robust;
• technically superior; and
• cost‑effective.

And most importantly, they can be delivered with confidence, even on tight timelines. 

Please reach out to discuss your own migration needs.