70% of New Insurance Apps Are Built on Low-Code. Legacy Players Can’t Keep Up.

The Hook

Something fundamental is shifting in insurance technology. For decades, insurance has been the last bastion of monolithic systems, hand-coded in COBOL and Java, protected by layers of legacy architecture that make change slow and expensive. That era is ending, and it’s happening faster than anyone in the legacy insurance establishment anticipated. A new survey from Gartner shows that 70% of new insurance applications launched in 2025-2026 were built on low-code platforms. That’s not an incremental shift. That’s a platform revolution, and it’s exposing the vulnerability of traditional carriers in real time.

The Stakes

The insurance industry moves premiums worth $6.3 trillion globally. But it’s also an industry strangled by technical debt. The average large insurance carrier still runs critical underwriting systems built in the late 1990s. Policy issuance can take weeks. Customer onboarding is a multi-step nightmare. Claims processing depends on manual workflows and PDF attachments. For years, this slowness was acceptable because everyone moved at the same pace.

Not anymore. Insurtech startups are launching fully-featured insurance products in months, not years. They’re processing claims in days, not weeks. They’re onboarding customers in minutes. And they’re doing it with teams that are 5-10x smaller than the legacy players require. The gap isn’t closing; it’s widening. And the reason is almost entirely architectural: legacy insurance companies can’t move fast because they won’t abandon the monolithic systems that define their operational model.

The Promise

Low-code platforms give insurance companies something they’ve never had: velocity without the technical debt. Instead of writing millions of lines of code for policy management, underwriting, claims, and distribution, you configure workflows visually. Business logic that used to require a three-month development cycle can now be deployed in three weeks. And crucially, you can modify it again next week without cascading failures across the system.

For the insurance industry, this is transformative. It means niche carriers can launch specialized products (pet insurance, creator economy insurance, nano-policies) without building entire technology stacks from scratch. It means legacy carriers can finally modernize their core systems incrementally instead of betting the company on a decade-long system replacement project. And it means the barrier to entry for insurance innovation just dropped dramatically.

Context: Why Insurance Lagged Behind Tech

Insurance is fundamentally an information business, but it’s been managed like a manufacturing business. You have policies (inventory), customers (supply chain), and underwriters (production managers). The technology stack was built to optimize this industrial model: centralized underwriting, batch processing, long-cycle approvals. It worked when everyone processed business the same way.

But consumer behavior has shifted. People expect real-time quotes, instant policy issuance, and same-day claims processing. The old batch-oriented, paper-dependent systems can’t deliver that. And rebuilding the entire core system to handle real-time workflows requires a wholesale architectural change that legacy carriers have been hesitant to undertake.

Enter low-code. It provides a bridge. You don’t abandon the legacy core systems (which still work fine for core underwriting logic and risk calculation). Instead, you build new, faster applications on top of them. You create APIs that expose the legacy system’s data in a modernized way. And you use low-code to quickly build the new customer-facing workflows that actually need to be fast.

The Numbers

Here’s where the data becomes undeniable:

• Time to market compression: Low-code insurance applications reduce development time by 60-70%. A traditional policy management module takes 12-18 months. The same functionality built on low-code platforms? 4-6 months. For niche insurance products, the difference is even more dramatic: 3-6 months vs. 18-24 months.
• Cost delta: Average development cost for a mid-sized insurance application: $8-12 million (traditional). Same application on low-code: $2.5-4 million. That’s a 65% cost reduction, not adjusting for the speed advantage (which compounds the value).
• Team size requirement: Traditional insurance development typically requires 25-40 engineers for complex systems. Low-code delivery achieves the same with 6-10. That’s a 4-6x efficiency gain. For a carrier, that translates to $3-5 million annual salary savings per project (including overhead).
• Adoption velocity among startups: 70% of new insurance startups founded in 2024-2025 built on low-code or no-code platforms. Among traditional carriers, only 18% have launched new applications on low-code. That’s a 4x adoption gap between startups and incumbents.
• Business impact metrics: Carriers that have implemented low-code for non-core processes report 45% faster claims processing, 38% reduction in customer service escalations, and 52% improvement in policy quote accuracy. These aren’t marginal gains; they’re transformative.
• Market capitalization signal: Insurtech platforms (Lemonade, Root, Hippo) that were built on modern architecture trade at 3-5x revenue multiples. Traditional carriers with legacy systems trade at 0.8-1.2x revenue. The market is pricing in the architectural advantage.

The Analysis: What’s Actually Happening

This is a classic case of architectural lock-in meeting technological disruption. Legacy insurance carriers have competitive advantages that are real: brand, customer relationships, capital, distribution networks. But those advantages are anchored to a technology foundation that was built for a different era.

Low-code platforms lower the barrier to entry in a way that neutralizes some of those advantages. A startup with $10 million in funding can now build an insurance product that competes on speed, personalization, and user experience with carriers that have thousands of engineers. That’s fundamentally destabilizing.

But here’s what’s interesting: the adoption gap between startups and legacy carriers suggests that organizational inertia is as much a barrier as technical capability. Major carriers have the capital to fund low-code transformations. But they don’t, because doing so would require admitting that their current systems are inadequate. It’s easier to invest in incremental improvements to legacy systems than to acknowledge they need to be replaced.

Additionally, low-code creates new problems. It lowers barriers to deploying applications, but it doesn’t eliminate the need for compliance, risk management, and governance. Insurance regulations are complex and non-negotiable. A low-code platform can help you deploy faster, but it doesn’t solve the fundamental regulatory challenges that slow insurance innovation. In some ways, the shift to low-code will expose organizational weaknesses that were previously hidden by technical complexity.

The Contrarian Take

Low-code is being positioned as a silver bullet for insurance innovation. It’s not. Yes, it accelerates development. But the real bottleneck in insurance isn’t development anymore; it’s regulatory approval and capital adequacy. You can build a new insurance product in three months on a low-code platform. But you still need to get it approved by state regulators, secure reinsurance, and maintain statutory reserves. Those processes still take 12-18 months. The speedup you get from low-code is real, but it’s being applied to a portion of the timeline, not the whole cycle.

Additionally, low-code platforms create a false sense of democratization. Yes, they lower the barrier to entry for development. But they concentrate power in platform vendors. Salesforce, Microsoft, Mendix, Appian—these are the true winners of the low-code revolution. Insurance companies adopting low-code are trading dependence on legacy vendors (Accenture, IBM, Deloitte) for dependence on platform vendors. That’s not liberation; it’s just different lock-in.

Finally, the 70% figure is misleading. It counts “new applications,” which tend to be smaller, non-critical systems. The core insurance functionality—underwriting, pricing, risk assessment, reserving—still requires traditional development. Low-code is winning in the periphery (policy servicing, customer portals, distribution tools), not in the core. That’s still important, but it’s not the existential threat to legacy carriers that the headlines suggest.

Three to Five Key Takeaways

• Low-code is reshaping the competitive landscape, but slowly: 70% of new applications built on low-code is real. But incumbents still have time to adapt. The shift happens over 5-10 years, not overnight. That said, the direction is irreversible.
• Speed in the periphery, not the core: Low-code shines for customer-facing, non-critical applications. Core underwriting and pricing still require traditional development. Understanding this distinction is crucial for carriers planning their modernization strategy.
• The real competitive advantage is now culture, not technology: Legacy carriers that embrace low-code will be those willing to admit their existing architecture is inadequate. That’s a mindset shift, and it’s harder than a technology shift. The 18% adoption rate among incumbents reflects this.
• Regulatory complexity hasn’t been disrupted: Low-code accelerates development but not regulatory approval. Insurance startups that use low-code still face the same 12-18 month approval timeline for new products. This limits the actual market advantage of the platform shift.
• Vendor lock-in just changed hands: Low-code doesn’t eliminate dependence on technology vendors; it shifts it from legacy vendors to platform vendors. Carriers need to think about exit strategies and data portability when selecting low-code platforms.

Your move. Subscribe to Goodmunity to get it first.