tangle-paypal-ai

It takes financial transaction data reconciles them, detects exceptions, and then uses AI/risk scoring to identify transactions that may need investigation.

Comment

Inspiration

Financial transaction data is often fragmented across invoices, payments, and bank records. When something doesn't match, finding the reason can require manually checking multiple records and systems. TANGLE was built to make that process more intelligent and structured. The idea is to create a system that can automatically connect transaction records, detect exceptions, assess their risk, explain what needs attention, and keep a clear human-review and audit trail. For the PayPal AI Hackathon, the vision is to take this further by making PayPal Sandbox transaction data a real input into TANGLE's investigation and governance workflow.

What it does

TANGLE is an AI-powered transaction governance and investigation platform. It currently:

  • Imports invoice, payment, and bank transaction datasets
  • Reconciles transactions using exact and fuzzy matching
  • Detects exceptions such as missing payments and missing bank transactions
  • Handles more complex reconciliation scenarios such as merged payments
  • Calculates transaction priority/risk scores
  • Classifies cases into risk levels such as Critical, High, and Medium
  • Determines when human review is required
  • Provides an investigation workflow for individual cases
  • Supports human review decisions such as approval, rejection, and escalation
  • Maintains an audit trail of important case changes
  • Provides dashboards and analytics for transaction risk and exception monitoring
  • Performs data-quality checks before/while processing transaction data The planned PayPal integration will extend this workflow: PayPal Sandbox → TANGLE → Reconciliation → AI Investigation → Risk Scoring → Human Review → Audit Trail ## How I built it TANGLE is built as a full-stack application. Backend
  • Python
  • FastAPI
  • PostgreSQL
  • JWT-based authentication
  • Argon2 password hashing
  • Service-based backend architecture
  • Transaction reconciliation and risk-analysis services AI / intelligence layer TANGLE uses an agent-oriented architecture for:
  • Exception detection
  • Risk/priority assessment
  • Investigation recommendations
  • Human-review management Frontend
  • React
  • Vite
  • Modern dashboard/application interface
  • Case investigation screens
  • Data ingestion interface
  • Review workflow
  • Analytics and risk visualization ## Challenges I ran into One of the biggest challenges was turning transaction matching into something more useful than a simple database lookup. Real transaction data doesn't always have a perfect one-to-one relationship. Payments can be missing, references can differ, and one payment can relate to multiple invoices. Another challenge was designing the system so that AI does not simply make an unexplained decision. TANGLE therefore combines automated intelligence with: risk scoring + explainable investigation findings + human review + audit history. I also had to handle data-quality problems without silently modifying the underlying source data. Finally, preparing the project for a public hackathon repository introduced another challenge: protecting secrets, separating backup files from production source code, preserving Git history, and creating a reproducible project structure. ## Accomplishments that I'm proud of I'm particularly proud that TANGLE is already a functioning end-to-end system rather than just a concept or UI prototype. The current system has:
  • 202 transaction cases
  • Automated reconciliation
  • Risk classification
  • Human-review workflow
  • Audit history
  • Data-quality monitoring
  • Authentication and role-based access
  • Investigation workflows
  • Analytics dashboards
  • A working React frontend and FastAPI backend I also built the project incrementally and preserved the development history through Git, allowing the evolution of the system to remain traceable. The project is now publicly available on GitHub: https://github.com/Vishal-240714-da/tangle-paypal-ai ## What I learned I learned that transaction intelligence is not just about finding mismatches. A useful system needs to answer: What happened? Why is it unusual? How risky is it? What should happen next? Does a human need to decide? Can we prove what happened later? Building TANGLE also taught me how important it is to combine automated systems with human oversight rather than treating AI output as an unquestionable final decision. On the engineering side, I gained experience working across database design, APIs, authentication, transaction processing, frontend development, risk logic, auditability, and Git-based project management. ## What's next for tangle-paypal-ai The biggest next step is PayPal Sandbox integration. The goal is to make PayPal a genuine part of TANGLE's transaction pipeline rather than simply adding PayPal as a payment button. After the PayPal integration, the next priorities are:
  • Secure PayPal credential management
  • Improve observability and logging
  • Create a polished hackathon demo dataset
  • Containerize the application
  • Improve setup documentation
  • Deploy a demo environment if practical
  • Prepare the <3-minute hackathon demonstration
  • Submit the project through Devpost
Share this project:

Updates