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. Honest feature parity for an agency, end to end.

What we built

Not a marketing demo. The shape an actual carrier or MGA would need:

• 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.

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.