1. Inspiration
Insurance can be confusing for users who struggle to understand policy terms, compare coverage options, identify exclusions, and navigate the purchasing process. Important information is often presented in technical language, making it difficult for users to make informed decisions.
We built PolicyPilot to make insurance exploration more accessible by combining AI-powered assistance with a structured insurance-plan selection experience and secure payment processing. Our goal is to simplify the journey from understanding an insurance plan to completing a payment through a familiar digital interface.
2. What it does
PolicyPilot is an AI-powered insurance assistance web application that brings insurance-plan discovery, conversational assistance, and payment processing into one platform.
Its key features include:
- AI-powered assistance: Uses Google Gemini to provide conversational responses to users' insurance-related questions.
- Insurance plan discovery: Displays available insurance plans, including premiums, coverage information, and plan descriptions.
- Plan selection: Allows users to explore and select a plan through the web interface.
- Payment integration: Integrates PayPal's developer platform in Sandbox mode to support test payment workflows.
- Database integration: Uses Supabase to store insurance-plan information and payment records.
- Backend API: Uses a Node.js and Express backend to handle requests and connect the frontend with AI, database, and payment services.
PolicyPilot is a prototype designed to demonstrate how AI and digital payments can improve the insurance discovery and purchasing experience. Any insurance plans used for demonstration are illustrative and do not represent actual insurance offers.
3. How we built it
We developed PolicyPilot using a modular full-stack architecture.
- Frontend: Built the user interface with React and Vite, including the insurance-plan display, AI chat interface, and payment-related components.
- Backend: Used Node.js and Express to build API endpoints and coordinate communication between the frontend, database, AI service, and payment provider.
- Database: Integrated Supabase to manage insurance-plan data and payment-related records.
- AI integration: Connected Google Gemini through the Google AI Studio API to power conversational assistance.
- Payment integration: Integrated the PayPal Developer Platform using its Sandbox environment for testing payment workflows without real financial transactions.
- Configuration and security: Used environment variables for API credentials and kept sensitive backend credentials out of the frontend.
- Testing and debugging: Worked through API connectivity, database queries, route configuration, and frontend-backend integration to bring the components together.
The architecture separates the presentation layer, backend business logic, AI functionality, database operations, and payment processing so that individual components can be maintained and improved independently.
4. Challenges we ran into
- Frontend-backend integration: Ensuring that React components communicated correctly with the Express API.
- Database connectivity: Configuring Supabase credentials, connecting the backend to the correct project, and troubleshooting database queries and access permissions.
- Payment integration: Configuring PayPal Sandbox credentials and coordinating the payment workflow with backend endpoints.
- AI integration: Connecting Gemini to the backend and handling requests and responses reliably.
- Debugging and configuration: Resolving import paths, JavaScript module configuration, API route conflicts, and environment-variable issues.
- Data consistency and security: Designing the application so that plan information and payment records can be managed centrally rather than relying only on frontend data.
5. Accomplishments that we're proud of
- Built a full-stack insurance assistance application that brings AI, insurance-plan discovery, database connectivity, and digital payments into one experience.
- Integrated Google Gemini to make insurance-related information more accessible through conversational interaction.
- Incorporated PayPal's developer platform and Sandbox payment environment into the application architecture.
- Connected the application to Supabase for structured insurance-plan and payment data management.
- Developed a modular architecture that can be extended with additional plans, AI capabilities, and payment features.
- Gained practical experience integrating multiple third-party services into a single application.
Our biggest accomplishment is bringing together technologies that are often developed separately into one cohesive insurance-assistance prototype.
6. What we learned
Through this project, we learned how to:
- Build and connect a React frontend with a Node.js and Express backend.
- Design API endpoints and troubleshoot HTTP errors.
- Connect an application to Supabase and work with relational database tables.
- Integrate an AI service using an API.
- Work with PayPal's developer tools and understand the role of Sandbox testing.
- Manage environment variables and protect API credentials.
- Debug dependency, import, configuration, and database-permission issues.
- Structure a project into modular components and services.
- Approach a real-world problem by combining AI, data management, and payment technology.
The challenges we faced during the development of this project helped us understand that a successful full-stack application requires more than a working interface: every service must communicate correctly, and important operations must be validated on the backend.
The project reinforced the importance of testing complete user workflows, not just individual features.
What's next for PolicyPilot
Our next step is to evolve PolicyPilot from a functional prototype into a more comprehensive, reliable, and user-friendly insurance assistance platform. We plan to introduce personalized insurance recommendations based on users' needs, multilingual AI assistance, and simplified explanations of policy documents, coverage, exclusions, and claim procedures. We also aim to strengthen the PayPal payment workflow, improve transaction verification and notifications, and expand database management and security. Future versions could integrate with verified insurance-provider APIs to provide up-to-date policy information and support a more complete digital purchasing journey. Our long-term vision is to make insurance easier to understand and more accessible by combining responsible AI assistance, transparent information, and reliable digital payment technology. With further testing, industry collaboration, and appropriate regulatory compliance, PolicyPilot has the potential to become a practical digital companion for users navigating insurance decisions.
Built With
- css
- dotenv
- express.js
- github
- googleaistudioapi
- html
- javascript
- node.js
- npm
- paypaldeveloperplatform
- paypalsandboxenvironment
- postgresql
- react
- restapis
- supabase
- vite