Insurease: A Liquid UI Platform

AI that transforms insurance buying from complex forms into simple voice conversations. Chat, speak, or video call to get personalized recommendations and buy policies hands-free.

Comment

Insurease: Making Insurance Easy, One Conversation at a Time

The Spark of Inspiration

We've all been there: navigating the confusing, soul-crushing world of insurance. It's a maze of jargon-filled websites, endless forms, and a nagging feeling that you're not getting the right coverage. The process is fundamentally broken; it's designed around policies, not people.

The inspiration for Insurease came from a simple, powerful question:

What if buying insurance felt as easy as talking to a smart, trusted friend?

I envisioned a world where you could simply state your needs in plain English, and a helpful AI advisor wouldn't just give you links, but would build the entire application experience around you, in real-time. No more hunting for information, no more repetitive data entry—just a single, elegant conversation that guides you to the perfect protection.

That vision is what drove every line of code in this project.

What I Learned: Building at the Speed of Thought

This hackathon was an incredible lesson in the power of modern development stacks. The biggest takeaway was the sheer velocity you can achieve by combining the right tools.

From Zero to Full-Stack in Hours

Using Supabase as an all-in-one backend (Postgres DB, Auth, and Edge Functions) was a game-changer. It allowed me to have a production-grade backend up and running in minutes, not days.

AI as a True Co-Pilot

This project would not have been possible in this timeframe without Cursor. It was more than a code generator; it was a partner in architecture. It helped:

  • Scaffold entire React components
  • Write complex database queries from my ERD
  • Generate boilerplate for Supabase Edge Functions

This freed me up to focus on the most critical part: the user experience and the core logic.

The Power of a "Golden Path"

The biggest technical lesson was the importance of defining and stabilizing a core user journey. In a time crunch, it's tempting to build a dozen half-working features. Instead, I focused on perfecting the "golden path": from the first spoken word to a fully submitted application in the database.

This meant making tough strategic calls, like temporarily sidelining a complex video integration to ensure the core voice and application flow was flawless for the demo.

How I Built Insurease: A Symphony of Modern Tech

Insurease is not just a chatbot; it's a Liquid UI platform, orchestrated by an AI agent named Maya. Here's how the magic happens:

🏢 The Foundation (Backend)

The entire project is powered by Supabase:

  • Robust Postgres database holds all user, policy, and application data
  • Secure Supabase Edge Function acts as a proxy for the ElevenLabs API, ensuring API keys are never exposed client-side
  • Architecture: Secure, scalable, and incredibly fast to set up

The Brain (AI Service)

The core logic lives in a custom-built aiService using TypeScript:

  • Built a pragmatic, rule-based intent analysis engine
  • Lightning-fast and predictable
  • Instantly understands user requests like "I need health insurance" or "I want to apply"
  • Generates UI actions based on detected intent

The Experience (Frontend)

Built with React, Vite, and TypeScript, the frontend is where Insurease truly shines:

Core Component: LiquidUI.tsx

This component acts as an orchestrator, taking UI actions from the AI Service and dynamically rendering rich, interactive components:

  • A user's query for policies doesn't return a text link; it renders the LiquidPolicyCarousel component directly into the chat
  • A request to apply for a policy seamlessly transitions to the ApplicationForm component
  • Framer Motion is used extensively to give the UI a fluid, polished, and premium feel
  • ElevenLabs voice integration makes the experience truly conversational and accessible

The Challenges I Faced

Every ambitious project faces hurdles, and Insurease was no exception.

Integration Complexity

The biggest challenge was integration complexity. My vision included:

  • Real-time voice (with elevenlabs)
  • Real-time video (with Tavus)
  • Live database connection
  • All managed by a stateful UI

Early on, I realized that getting all three of these advanced, real-time services working together perfectly in a short timeframe was a recipe for a buggy demo.

The Strategic Decision

I hit a wall trying to stabilize the live video streaming alongside the voice and chat interfaces. It was a classic hackathon dilemma:

Chase the "wow" factor at the risk of stability, or focus on a rock-solid core experience?

I made the tough but crucial decision to strategically de-risk:

  • Perfected the core platform and ElevenLabs voice integration
  • Built architectural hooks for video and advanced geo-location as clear, achievable "next steps"

It was a powerful lesson in prioritizing what truly delivers value to the user.

The Vision Realized

Insurease is my answer to a broken industry. It's a testament to how modern AI and thoughtful design can transform a dreaded task into a delightful experience.

Key Achievements

  • Voice-First Experience: Natural conversation flow with AI
  • Liquid UI: Dynamic, context-aware interface generation
  • Real-Time Intelligence: Instant intent recognition and response
  • Production-Ready: Secure, scalable architecture from day one

What's Next

  • Full video integration with Tavus
  • Advanced geo-location services
  • Enhanced analytics and personalization
  • Integration with real insurance providers

And This Is Just the Beginning

Insurease represents a fundamental shift in how we think about insurance technology. By putting conversation at the center of the experience, we're not just building software—we're building trust, understanding, and ultimately, better protection for families everywhere.

The future of insurance isn't about better forms; it's about better conversations. And with Insurease, that future is here.

Built With

  • cursor
  • dynamic-component-render
  • elevenlabs
  • framer
  • liquid-ui
  • react
  • supabase
  • typescript
  • vite
Share this project:

Updates