Expert Insights

AI Can Write the Code. But Can It Build an Insurance Policy Administration System

AI Can Write the Code. But Can It Build an Insurance Policy Administration System

By Mia Geringer | SolveCo Actuarial Services

AI is changing how software is developed. But when it comes to building a life insurance policy administration system, writing the code is only one part of the challenge.

At the recent ASSA convention, I heard actuarial professionals discussing how AI-driven system development is increasingly being promoted within their organisations. The thinking seems straightforward: if the actuarial team understands the products, the product specifications are available, and the IT team has access to AI coding tools, why not build the administration system internally rather than pay an external software vendor?

It is an understandable argument. Traditional policy administration system (PAS) implementations can be expensive and time-consuming. AI is making software development faster and more accessible, creating opportunities that would have been difficult to contemplate just a few years ago.

But there is an important distinction between being able to generate software and being able to build a complete, reliable insurance administration system.

Having worked across insurance system implementations for many years, one of the most important lessons I have learnt is that product specifications are only the starting point. They are not a blueprint for an entire administration system.

The real challenge is not simply writing code. It is understanding the business, translating its rules into a working system, anticipating exceptions, validating the results and ensuring that the platform can evolve as the business changes.

Actuaries understand insurance products. IT professionals understand technology. Both bring essential skills to a system development project. The challenge arises when it is assumed that the product specification contains sufficient detail for IT to build the system.

A product specification might explain premiums, benefits, exclusions, waiting periods and eligibility criteria. It may describe how a benefit is calculated and when it becomes payable. But a policy administration system must do considerably more than calculate premiums and determine benefits. It must manage the complete policy lifecycle, including new business, underwriting, policy amendments, premium collection, arrears, lapses, reinstatements, cancellations, claims, commissions, financial transactions, reporting and integrations with other systems. It must also handle the exceptions.

What happens when a policy is backdated? How should a premium received after a policy has lapsed be treated? What happens when a transaction is reversed after a commission has already been paid? How should an amendment affect previous calculations and future transactions?

These are not necessarily questions that will be answered in a product specification. They often emerge through detailed business analysis, discussions with operational teams, implementation experience and a thorough understanding of how insurance administration works in practice. Even when the product rules are fully documented, the system still needs transaction processing, security, audit trails, data management, accounting interfaces, operational controls, testing and error handling.

Knowing how an insurance product works is not the same as knowing everything an administration system must do to support it.

AI can generate code, build interfaces, create database structures and assist with calculations. It can turn well-defined requirements into working software far more quickly than traditional development methods in many situations. This is a genuine opportunity.

The difficulty is that AI works from the instructions, context and assumptions it is given. When requirements are incomplete, it may make assumptions that appear logical but do not reflect the insurer’s actual business rules. It can also produce code that works perfectly in isolation but fails when combined with other processes, transaction sequences or exceptions.

Consider a premium calculation. Generating the calculation itself may be relatively straightforward. Ensuring that it remains correct after a policy amendment, a missed payment, a reinstatement or a backdated transaction is a different challenge. Each additional product, commission structure, distribution channel and operational rule introduces further complexity.

AI can help developers work through this complexity, but it cannot independently establish that every business rule has been identified, interpreted correctly and implemented consistently.

The risk is not necessarily that the system will fail immediately. It is that it will appear to work while important errors remain undiscovered.

The answer is not to avoid AI. It is to understand where it adds value and where its outputs need to be validated by experienced people.

There are several areas in which AI can significantly improve the development of insurance administration systems:

AI can help turn workshop notes, product documentation and business requirements into structured specifications. It can identify missing information, highlight inconsistencies, generate process flows and suggest questions for business stakeholders.

However, an experienced insurance specialist must validate the interpretation and ensure that the requirements reflect the actual product and operating rules.

AI can generate code for clearly defined functions, develop application interfaces, create data structures and help developers investigate defects. It can also explain existing code and suggest improvements. This can reduce development effort, particularly for repetitive tasks and well-defined functionality. But generated code is not necessarily correct simply because it compiles or passes a basic test.

AI can generate test scenarios from specifications, including positive tests, negative tests, boundary conditions and unusual combinations of events. For example, it can help create test cases covering missed premiums, policy reinstatements, benefit changes, cancellations and commission calculations.

This becomes particularly valuable when an experienced tester reviews the scenarios, identifies additional business risks and ensures that the expected results are correct.

AI can help profile datasets, identify anomalies, suggest data mappings and highlight inconsistencies between legacy systems and a new administration platform.

It can accelerate the investigation of migration problems, but the mapping rules, reconciliations and acceptance criteria must still be determined and verified by people who understand the underlying insurance data.

AI can assist with technical documentation, user guides, release notes and requirements traceability. It can also help development teams understand unfamiliar parts of a system and reduce the effort required to maintain documentation.

These capabilities are meaningful. They can improve productivity, shorten certain development activities and allow specialists to focus on more complex decisions. The opportunity is to use AI to make experienced people more effective, rather than assume that AI eliminates the need for their expertise.

One of the main arguments for in-house development is the potential saving from not purchasing a vendor solution. But comparing a vendor’s licence or implementation fee with the cost of AI-assisted coding is not a like-for-like comparison. Building a production-ready policy administration system requires investment in much more than development.

It requires detailed business analysis, architecture, product configuration, transaction processing, testing, data migration, implementation management, training, ongoing support and maintenance. Every one of these activities consumes time and resources. And those resources are not free simply because they are already employed by the organisation.

When internal actuarial, IT, finance and operations teams are allocated to building a system, they have less capacity to deliver their existing responsibilities. Business-as-usual activities may slow down, other projects may be delayed, and specialist employees may become tied up in a development programme for years.

There is also an opportunity cost. What else could those employees have delivered during the same period? A project that appears inexpensive because it uses existing staff can become costly when the full value of their time, competing priorities and the extended development period is taken into account.

AI may reduce the effort required for some activities, but it does not remove the need for business analysis, independent assurance, implementation expertise or operational readiness.

The real comparison should be between the total cost of ownership of an internally developed system and the total cost of an appropriate vendor solution, including implementation, customisation, integration, maintenance, upgrades and future development.

The question is not simply whether a company can build its own system more cheaply. It is whether it can build, implement, operate and maintain that system at a lower total cost and with an acceptable level of risk.

Perhaps the biggest commercial risk is not the initial decision to build a system. It is what happens when the organisation discovers, partway through the project, that its original assumptions were wrong.

A team starts with a manageable scope. A few products are selected, requirements are documented and development begins. As work progresses, additional requirements emerge. Commission rules prove more complicated than expected. Product variations need to be accommodated. Migration exposes inconsistencies in the legacy data. Finance identifies accounting requirements that were not included in the original design. Operations raises scenarios that the system cannot yet handle. The scope expands, timelines increase and more resources are allocated.

Eventually, management faces a difficult choice: continue investing, reduce the scope, delay the launch or reconsider the approach entirely. By that point, substantial money and internal capacity may already have been committed. This creates a sunk-cost problem. Management may continue funding the project because so much has already been invested, even when a different approach deserves serious consideration.

The more tightly the software has been built around its original assumptions, the more expensive it can become to change direction. This is particularly problematic when the system was designed for a narrow set of products but later needs to support a wider product range, different distribution models, more complex commission structures or additional business requirements.

The organisation may find itself choosing between continuing to fund a solution that no longer meets its needs and writing off a substantial investment. The cost of getting the initial decision wrong can be far greater than the cost of the software itself.

A policy administration system is not simply a development project with a defined end date. It becomes a long-term business asset that must evolve with the insurer. Products change. Commission structures change. Regulatory requirements change. Business models change. Acquisitions may introduce new books of business, and legacy platforms may need to be integrated or retired.

A system that is easy to demonstrate at the beginning may become difficult to maintain once it contains years of business rules, product-specific exceptions and dependencies between modules. AI-generated code is not automatically modular, consistent or easy to maintain. Those qualities depend on architecture, design decisions, development standards, documentation and ongoing governance.

Without these disciplines, the organisation may end up with a system that is technically operational but expensive to enhance. It may also become dependent on a small group of employees who understand how it works. If key developers leave, maintaining and extending the platform can become even more difficult.

The decision to build internally therefore creates a long-term commitment to ownership, not just a short-term development exercise. This is one of the reasons why the initial business case must consider the full lifecycle of the system rather than focus only on the time and cost required to produce the first working version.

There are several areas where AI should support, rather than replace, experienced insurance professionals.

Someone must understand the insurance product, interpret its contractual terms and make decisions where requirements are ambiguous. This includes determining how premiums, benefits, exclusions, waiting periods, commission structures and policy events should operate together.

AI can help analyse these rules, but the insurer and its appropriately qualified specialists remain accountable for the decisions.

Insurance administration systems manage money, liabilities and contractual obligations.

Premium allocations, commission calculations, policy values, claims payments and financial postings must be accurate and reconcilable.

The challenge is not simply calculating the correct amount once. It is ensuring that the calculation remains correct when transactions are reversed, amended, backdated or processed in a different sequence. Experienced professionals must define the expected financial outcomes and independently validate them.

A PAS must do more than perform today’s tasks. It must accommodate future products, regulatory changes, integrations, increasing transaction volumes and ongoing maintenance.

AI can propose architectural solutions, but experienced architects and developers must assess the implications of those choices, including data integrity, security, performance, maintainability and the cost of future changes.

A system can pass hundreds of generated tests and still contain a critical defect because the tests reflect the same incorrect assumptions used during development.

Independent validation is therefore essential. Expected results should be established from approved business rules, actuarial calculations and financial requirements, rather than simply accepting the output produced by the new system.

Migration and parallel-run testing are equally important. Policy records, premiums, benefits, commissions, claims and financial balances must be reconciled between the old and new systems, with discrepancies investigated and resolved.

Ultimately, the insurer needs evidence that the system is ready for production, not merely confidence that the software has been built.

One of the most difficult aspects of a PAS project is identifying what has not been specified.

An experienced insurance systems specialist knows which questions to ask, where exceptions tend to arise, which dependencies can affect other modules and which scenarios need particular attention during testing.

That knowledge is often developed through years of working on implementations, investigating defects, validating migrations and dealing with the realities of live insurance operations. It cannot be replaced simply by giving an AI tool access to a product specification.

At SolveCo, our experience across more than 50 insurance system implementation and testing engagements has reinforced the importance of understanding the full picture: the product, the administration processes, the data, the financial transactions and the operational environment.

We also recognise the opportunities AI creates. In developing LUNA PAS, our own life insurance policy administration platform, we incorporate AI into our development process while retaining the structured requirements, insurance expertise and testing disciplines needed to build a reliable system.

The objective is not simply to generate more code in less time. It is to deliver a system that insurers can operate with confidence.

Our experience has also taught us that successful implementation depends on asking the right questions early, understanding the full scope and establishing appropriate controls before significant investment is committed.

Before committing to an in-house PAS development programme, management should look beyond the initial coding estimate.

Some important questions include:

  • Have we documented the complete policy lifecycle, including exceptions and historical transactions, or only the product rules?
  • Have we estimated the effort required for business analysis, testing, migration, implementation and ongoing support?
  • Can we support the project without compromising existing business priorities?
  • Is the proposed architecture designed to accommodate future products and changes?
  • How will we independently validate calculations, financial transactions and migrated data?
  • Who will own the platform, maintain it and support it over the next five to ten years?
  • What are our decision points if costs increase, timelines slip or the scope proves more complex than anticipated?
  • Have we compared the total cost and risk of in-house development with suitable vendor alternatives?


A credible business case should include phased delivery, measurable acceptance criteria, independent assurance and clear points at which management can reassess whether to continue. These controls do not guarantee success, but they help prevent an ambitious technology initiative from becoming an open-ended commitment.

Building internally may be the right decision for some insurers. Others may find that a vendor platform or a hybrid approach provides a better balance between cost, flexibility, control and implementation risk. The important thing is to make that decision based on the full picture, rather than on the assumption that faster coding automatically means a cheaper system.

Conclusion: AI can write the code. But building the right system takes more.

AI is transforming software development, and its contribution to insurance administration systems will continue to grow. But a life insurance policy administration system is not simply a software product. It is the operational infrastructure through which an insurer administers contractual obligations, manages financial transactions and serves policyholders.

Building one requires a deep understanding of insurance products, policy lifecycles, financial processes, data migration, operational requirements and the controls needed to protect policyholders and insurers. AI can help build the system. Experienced people must help determine what the system should do, verify that it does it correctly and establish that it is fit for use.

The competitive advantage will not necessarily belong to those who use AI to generate the most code. It will belong to those who combine AI with the expertise to build the right system, validate it properly and implement it successfully.

AI can reduce the cost of writing software. It does not automatically reduce the cost of building, validating, implementing and maintaining an insurance administration system. And in a project of this scale, understanding that distinction at the beginning may be the most valuable investment of all.

Share:

Please feel free to contact us if you would like to discuss this in more detail

AI Can Write the Code. But Can It Build an Insurance Policy Administration System

AI Can Write the Code. But Can It Build an Insurance Policy Administration System

Why insurance systems require more than AI-generated code? By Mia Geringer | SolveCo Actuarial Services AI is changing how software […]

Why Insurance System Implementations Really Go Wrong

Lessons from Supporting Implementations, Upgrades And Migrations Across Southern Africa By Mia Geringer | SolveCo Actuarial Services After supporting insurance […]

Inside Insurance System Implementations: ThoughtExpress (Orfeo / GaiaLex)

Lessons from Supporting ThoughtExpress Implementations Across Southern Africa By Mia Geringer | SolveCo Actuarial Services After supporting insurance system implementations […]

Inside Insurance System Implementations: Sapiens

Lessons from Supporting Sapiens Implementations Across Multiple Markets By Mia Geringer | SolveCo Actuarial Services After supporting insurance system implementations […]

SolveCo MIP Insurance Platform implementation

Inside Insurance System Implementations: MIP

Lessons from Supporting MIP Implementations, Upgrades and Migrations Across Southern Africa By Mia Geringer | SolveCo Actuarial Services After supporting […]

Inside Insurance System Implementations: Exergy

Lessons from Supporting Exergy Implementations Across Southern Africa By Mia Geringer | SolveCo Actuarial Services After supporting insurance system implementations […]

Scroll to Top