Inspiration
Online payments are widely used, but understanding and managing payment activities can still feel complicated for users. We wanted to make the payment experience more conversational, accessible, and intelligent.
This inspired us to build PayPilot, an AI-powered assistant that combines natural-language interaction with PayPal payment functionality. Our goal is to help users understand payment requests, follow a guided checkout process, and gain useful insights from transaction data.
What it does
PayPilot is an AI-powered payment assistant built around the PayPal payment workflow.
Its key features include:
- AI Payment Assistant: Allows users to describe payment-related requests in natural language.
- PayPal Integration: Uses the PayPal REST API to create payment orders and provide an approval link.
- Guided Checkout: Allows users to review and approve a payment through the PayPal checkout process before capture.
- Transaction Management: Stores transaction information and displays payment activity.
- Dashboard: Provides an overview of payment activity and transaction statistics.
- AI Financial Insights: Uses AI to generate helpful summaries and insights from available transaction data.
The current prototype uses PayPal Sandbox for testing and demonstration, not real-money transactions.
How we built it
We developed PayPilot using Python and Streamlit to create an interactive dashboard and AI assistant interface.
Our technology stack includes:
- Python: Core application logic and backend functionality.
- Streamlit: Interactive dashboard and user interface.
- Google Gemini AI: Natural-language understanding and AI-powered insights.
- PayPal REST API: Payment order creation, approval workflow, and capture.
- SQLite: Local storage for transaction records.
- GitHub: Source-code management and version control.
We organized the application into separate modules for the user interface, AI services, PayPal integration, database operations, and configuration management. We also developed automated tests to check important application components.
Challenges we ran into
One of our biggest challenges was integrating AI functionality with a payment workflow.
Some key challenges included:
- Connecting the application with the PayPal Developer Sandbox.
- Understanding and implementing PayPal OAuth authentication.
- Managing the order creation, approval, and capture process.
- Handling API responses and different payment statuses.
- Integrating Gemini AI with the application.
- Managing API credentials through environment variables and Streamlit secrets.
- Testing different application scenarios and preparing the project for deployment.
Working through these challenges helped us understand how AI applications can interact with payment APIs and how important reliability is in financial applications.
Accomplishments that we're proud of
We are proud to have developed a functional prototype that brings AI assistance and PayPal payment functionality together.
Our major accomplishments include:
- Building an interactive Streamlit dashboard.
- Integrating Gemini AI for conversational payment assistance and financial insights.
- Implementing the PayPal Sandbox order workflow.
- Creating a transaction management system using SQLite.
- Organizing the project into modular and maintainable Python files.
- Developing automated tests for important application components.
- Publishing the project on GitHub and preparing it for Streamlit Community Cloud deployment.
Most importantly, we transformed our idea into a tangible prototype that demonstrates how AI can make payment interactions more conversational and informative.
What we learned
During this project, we gained practical experience in:
- Integrating generative AI into a Python application.
- Working with the Google Gemini API.
- Understanding PayPal REST APIs and payment workflows.
- Implementing OAuth-based API authentication.
- Building interactive applications using Streamlit.
- Managing transaction data with SQLite.
- Handling API errors, credentials, and application configuration.
- Testing, debugging, and preparing an AI-powered application for deployment.
We also learned that AI can assist users with payment-related tasks, while payment authorization and processing must remain within a controlled payment workflow.
What's next for PayPilot – AI-Powered Payment Assistant
We aim to make PayPilot more intelligent, reliable, and useful in real-world payment scenarios.
Our future plans include:
- Improving natural-language understanding for more complex payment requests.
- Adding stronger payment validation and error handling.
- Improving transaction categorization and financial analytics.
- Introducing personalized insights based on transaction history.
- Enhancing the dashboard and overall user experience.
- Expanding testing across different PayPal Sandbox payment scenarios.
- Exploring additional payment-related workflows and integrations.
Our long-term vision is to build an intelligent payment assistant that simplifies payment interactions, helps users understand their transaction activity, and makes digital commerce more accessible through AI.
