Insurance Policy Platform

We keep coming back to one thesis: a lot of legacy enterprise software is protected by a moat that no longer exists. The license fee is big, the switching cost is real, but the underlying product is rebuildable on a modern foundation in a fraction of the time it used to take.

So we picked a category where that thesis is uncomfortable to argue with, insurance policy administration, and stood a product up against a well-known legacy system carrying a seven-figure annual license. A few weeks of focused build time got us to honest feature parity for an agency, end to end.

What we built

We built the shape an actual carrier or MGA would need, not a marketing demo:

Public marketing and landing pages.
Dynamic quote flows that branch by product and jurisdiction.
Online payment collection.
Account creation and customer sign-up.
Document generation for policies, declarations, and notices.
Full policy management across the lifecycle.
Multi-tenant configuration, from a single agency to an MGA-style tenant with hundreds of brokers, each carrying different products, all under one tenant.

The same surfaces a real customer touches, and the same surfaces an admin, broker, or operator lives in.

Why it was possible in a few weeks

The honest answer is that the slow, expensive parts were already done before the build started.

A modern stack, already wired. TypeScript end to end, a current framework, a typed API client, a managed database, deployment, and observability, on a foundation an AI assistant can actually reason about.
A design system, implemented in code. Tokens, primitives, forms, tables, navigation, dashboards. Production-ready, with the small details right: tabular numerals, hairline borders that respect dark mode, accessible focus.
A headless API at the core. The web app is one consumer of the backend, not the backend itself.

That meant the build time went almost entirely into insurance behavior: rating, eligibility, quote shaping, policy state, document templates, payment hooks, broker hierarchies, tenant configuration, instead of rebuilding the product surface from scratch.

Multi-tenant was the real test

A single-product demo for a single agency is not parity with a legacy policy- admin system. The legacy moat is partly about how messy this industry actually is, so the build had to handle the real shape: one small agency with their own branding and forms, and an MGA-style tenant managing hundreds of brokers with different products, commissions, and document templates, across jurisdictions, behind role-based access.

Almost none of that needed new “platform” code. It needed disciplined data modeling, a clean permission boundary, and components that could be configured rather than rewritten per tenant.

What the seven-figure license is actually buying

Once you watch a small team rebuild a category in a few weeks, you stop believing the price tag is about the software. The annual license is buying switching cost, long-running integrations, vendor relationships, compliance familiarity, and risk aversion at the buyer — plus the absence of a credible alternative.

Those are real, but they are commercial moats, not technical ones. They erode the moment a credible alternative exists that is materially better, materially cheaper, and materially faster to adopt.

Where this generalizes

Insurance is not the only category that looks like this. Several industries — especially in financial services — share the same shape: long-lived workflows wrapped in older interfaces, high annual licenses defended by switching costs, heavy document and regulatory overhead, and a customer experience the incumbent has never solved. Brokerages, lenders, advisory platforms, claims, and benefits administration routinely cost customers about ten times what the underlying software is worth to build today.

The opening isn’t a cheaper version of the legacy product — it’s a replacement that also fixes the experience that has been broken for a decade. A modern stack lets a small team do both at once, because the foundational work is no longer the schedule risk.

Why it matters

A few weeks to feature parity is the headline, not the lesson. The lesson is that the parts of an enterprise build that used to be hard (design system, headless API, modern tenancy, AI-assisted implementation) are now infrastructure. Invest once and they compound. Categories that looked untouchable become addressable by small, focused teams.

This was the test of that idea. It held up, and it’s the same playbook we bring to client work.