
Build vs buy AI in insurance: how to choose a platform, custom AI or both
Build vs buy AI in insurance comes down to which parts of the work are the same for every insurer and which are yours. Buy capabilities that are standard across the market, such as reading broker documents. Build what connects to your core systems, holds your rules or sets your products apart. For many insurers and MGAs, a mix of both is a practical place to start.
The question has got harder in the past year. AI products for underwriting and claims have multiplied, and AI coding tools make building faster than it used to be. Building something is easier. Owning it, keeping it compliant and connecting it to an older policy system is still real work.
This guide compares the three routes, the factors that decide between them, what regulators expect when AI comes from a vendor, and the questions to ask before you sign.
The three routes: buy, build or combine
In this guide, buying means a vendor's AI product for a specific task, such as reading submissions or triaging claims. It doesn't mean replacing your whole policy or claims system.
Buy a platform. A vendor's AI product for a task such as submission intake, claims triage or fraud scoring. You configure it, connect it and pay a licence or usage fee. The vendor owns the model and the roadmap.
Build on your own systems. Your team, or a partner working for you, builds the AI workflow around your data, rules and core systems, using models from cloud providers where they fit. You control the code and decide what changes and when, subject to IP ownership and third-party terms.
Combine them. Buy the capabilities that are the same for everyone, and build the parts that hold your rules and connect to your systems. Many insurers end up here whether they plan it or not.
Buy a platform | Build on your own systems | Combine | |
|---|---|---|---|
Who owns the logic | The vendor | You | You own the rules and integration; the vendor owns the bought parts |
Speed to a first release | Fastest for standard tasks | Slower to start | Fast where you buy, steady where you build |
Fit with your workflow | You adapt to the product | Fits your workflow | Fits where it matters most |
Cost pattern | Licence or usage fees that grow with volume | Upfront build, then hosting and maintenance | A mix of both |
Exit and portability | Depends on the contract and data export | You control the code and business logic, subject to IP and third-party terms | You can design bought parts to be replaceable |
What decides it
How specific the workflow is. Reading schedules of values and loss runs is a common need across insurers, and a specialist product has usually seen a wider range of document layouts than one insurer's team will. Your appetite, referral rules and the way you assess a niche commercial risk are yours. The more a task depends on your own rules, the stronger the case for building.
How much it touches your core systems. AI only saves time when its output lands where people work: the policy administration system, the rating engine, the underwriter workbench. If a platform can't read from and write to those systems through stable APIs, someone re-keys its output and the saving disappears. Integration is often where the real build work sits, even when you buy.
Where the data goes. Submissions and claims files hold personal and commercial information. Check where a vendor processes and stores it, whether it's used to train their models, and whether that fits your privacy obligations and any data residency terms in your contracts.
Total cost over time. Compare the cost over the years you expect to run the system. Licence and usage fees grow with volume. A built system needs hosting, monitoring, model updates and people who can maintain it. Either can be cheaper, depending on volume and how long you keep it.
Speed to a first release. If a product covers a standard task well, buying is usually the quicker way to prove value. Building takes longer at first, but each later release builds on the same foundation.
Lock-in and leaving. Ask what happens if you leave. Can you export your data, decision history and configuration in a usable form? If your rules live only inside a vendor's product, changing vendors means rebuilding them.
Who will own it. A built system needs a team, in-house or a partner, to maintain it, test model changes and answer regulators' questions about it. If nobody will own it for the long term, buying is safer. A bought system still needs someone to manage the vendor, the integration and compliance oversight.
A decision matrix
Factor | Points to buying | Points to building |
|---|---|---|
Workflow | Standard across the market | Depends on your rules, products or appetite |
Core systems | Few connections, or the vendor already integrates with your systems | Deep connections to policy, rating or claims systems |
Data | The vendor's handling meets your privacy and residency needs | Data has to stay in your environment |
Volume and cost | Low or uncertain volume | High, steady volume over several years, with integration and maintenance costed in |
Speed | You need results this quarter | You can invest in a foundation first |
Exit and portability | Clean data export and a short contract | Rules and decision history you must keep control of |
Ownership | No team to maintain it | A team or partner to own it long term |
If most answers point the same way, the decision is easy. If they split, that's the case for a hybrid, decided task by task.

What regulators expect when the AI comes from a vendor
When AI comes from a vendor, the insurer remains responsible for how it's used and the decisions it supports, wherever the model came from. A few examples:
United States. The NAIC Model Bulletin on the Use of Artificial Intelligence Systems by Insurers
expects an insurer's written AI program to cover AI systems and data bought from third parties. That includes due diligence to make sure decisions supported by those systems meet the legal standards the insurer itself must meet. Where available, it also expects contract terms that give audit rights or audit reports and require the vendor to cooperate with regulatory inquiries.
European Union. Under the EU AI Act, an insurer that uses a high-risk AI system, such as one for risk assessment and pricing of individuals in life and health insurance, has duties as a deployer from 2 December 2027. They include using the system as instructed, assigning human oversight to people with the competence and authority to do it, monitoring it, and keeping the logs the system generates, where they're under the insurer's control, for at least six months. Deployers of these insurance systems must also carry out a fundamental rights impact assessment before first use.
Australia. Under APRA's CPS 230, insurers must identify and manage their material service providers. These include providers the insurer relies on for a critical operation or that expose it to material operational risk, and insurers must classify providers of underwriting, claims management, insurance brokerage and reinsurance services as material unless they can justify otherwise. An AI vendor can fall into this group. Material arrangements need a formal, legally binding agreement covering the services, ownership and control of data, audit and APRA access, and termination rights. APRA must be told within 20 business days of entering into or materially changing an agreement for a service the insurer relies on for a critical operation, and before entering into a material offshoring arrangement, including where relevant data or personnel will be located outside Australia. CPS 234 adds that insurers must assess the information security capability of third parties that manage their information assets.
Whichever route you choose, these rules shape the contract and the design. With a bought platform, they decide what you need in writing from the vendor. With a build, they decide what the audit trail and approval points must record. This isn't legal advice, so confirm how the rules apply to you with your compliance team.
A hybrid in practice: AI in underwriting
Take submission intake for commercial property, the workflow covered in our guide to AI in insurance underwriting. A sensible split could look like this:
Buy document AI to read broker emails, schedules and loss runs and pull out structured fields. It's a common need across insurers, and specialist products are built for a wide range of document layouts.
Build the appetite and referral rules, the risk summary format your underwriters trust, and the integration that puts the prepared case into the workbench and the policy administration system.
Build the audit trail. Log each AI action the vendor exposes, its output and each underwriter decision in your own environment, in a format you control. Check what the vendor exposes and whether it can be exported, so the record stays with you if the vendor changes.
The bought component can be swapped. The rules, the data and the decision history stay yours.
Building the parts you own
The parts worth building are usually the ones that hold your rules and records: the rules engine, the audit trail, the integrations and the data model. With those in place, AI components can be added, tested and replaced without rebuilding the business logic each time.
Example: Numerisk's Granite platform
Whitefox built Granite for Numerisk from the ground up: a multi-tenant, API-driven insurance distribution and quoting platform covering quoting, underwriting rules and referrals, binding and the policy lifecycle, hosted in AWS Sydney. A few of its design choices matter for anyone weighing build vs buy:
Numerisk retains clear ownership of the platform's IP.
Underwriting logic is version-controlled, so rules can change safely and earlier decisions stay traceable.
Every action is logged in an immutable audit trail, with identity, timestamp and system context.
The rules engine supports automatic approval and flagged referral, with room to expand risk scoring logic.
That foundation gives Numerisk a way to introduce AI components, from document extraction to risk scoring, while keeping control of its underwriting rules and decision records. Read the Numerisk Granite case study.
Questions to ask an AI vendor
Is our data used to train your models, and can we opt out?
Where is our data processed and stored, and can that change without notice?
What does the system log for each decision, and can we export those logs?
How do you tell us about model changes, and can we test a new version before it goes live?
What happens if you discontinue the product, change the underlying model or move to a different AI provider?
How does the product explain an output to an underwriter, a customer or a regulator?
Which of our systems do you already integrate with, and through which APIs?
How does pricing change as our volume grows?
If we leave, what do we get back, in what format, and how quickly?
Will you support audits and cooperate with regulatory inquiries about our use of your product?
Costs people miss
When buying, the costs that get missed are integration and data mapping, usage fees at full volume, the configuration needed to fit your rules, and the time spent managing the vendor.
When building, they're monitoring and maintenance after launch, testing when the underlying models change, documentation for regulators, and keeping the people who know the system.
Neither list makes one route cheaper. They're the costs to include before you compare quotes.
Work out your build vs buy mix
If you’re deciding where to build vs buy AI in your insurance workflows, start with the workflow itself. We can walk through it with you, sort each task into buy, build or combine, and outline a first release that keeps your rules and records under your control.
Talk to us about a workflow review, or see how we built Granite for Numerisk.
Ready to Explore AI in Your Projects?
Let’s talk about how AI models can accelerate your engineering workflows
and unlock new possibilities.





