Inspiration
Inspiration
Money can cross a border in a few clicks, yet understanding what happens afterward can feel surprisingly difficult. Where is the payment? Why was it flagged? What made one route better than another?
We built Transnational around a simple belief: moving money should come with clarity. We wanted to explore how financial institutions could bring payment decisions, risk checks, routing, and settlement records into one understandable workflow.
What it does
Transnational is a prototype for cross-border payment orchestration. It brings the journey of an institutional transfer into one workspace—from entering payment details to reviewing its final audit trail.
Users can initiate a transfer, inspect a machine-learning fraud score, run simulated compliance checks, and review a route selected by Google OR-Tools using modeled fees, timing, and liquidity constraints. They can then follow demo funding, simulated settlement, and reconciliation through the application.
We also wanted to be honest about what we built. Fraud scoring uses a real model with synthetic benchmark inputs. Compliance checks and banking settlement are simulations. The running prototype records state changes in a local cryptographic audit ledger; live Hyperledger Fabric transactions are not connected.
How we built it
We built the interface with Next.js and TypeScript, giving users a place to compose transfers, inspect risk, and follow payment activity.
A NestJS backend coordinates the workflow and stores payment records in PostgreSQL. A separate Python service, built with FastAPI, runs LightGBM fraud inference, prototype compliance rules, and Google OR-Tools route optimization. Socket.IO carries payment updates back to the interface.
The repository also includes PayPal Sandbox integration code and Hyperledger Fabric infrastructure and chaincode. In our recorded demonstration, we used explicitly simulated funding and the local audit ledger.
The most meaningful part was connecting these pieces. A model score on its own is interesting. Seeing that score become part of a payment’s story is what made the project feel useful.
Challenges we ran into
Our biggest challenge was making several different systems speak the same language. A payment has to carry its information consistently through the interface, backend, AI service, database, and audit trail. Small mismatches can leave a working backend result invisible to the user.
Testing exposed exactly those kinds of gaps. The standalone routing screen expected a different response format, and the compliance lab did not display the status returned by its backend. One benchmark fixture also produced a much higher fraud score than its description suggested.
Those moments were frustrating, but valuable. They reminded us that a convincing interface is only one part of a working product. We had to check what actually happened behind every button—and be willing to explain what was still unfinished.
Accomplishments that we're proud of
We’re proud that we connected a real transfer initiation flow to model inference, compliance rules, route optimization, and a traceable sequence of payment states.
During verification, we created a transfer through the actual interface, inspected its computed route, applied demo funding, and completed simulated settlement and reconciliation. We checked the resulting demo balance changes and the audit entries generated along the way.
We’re also proud of choosing transparency. It can be tempting to describe a prototype only through its ambitions. We wanted ours to stand on what it could actually demonstrate, while leaving room to grow.
What we learned
We learned that financial software needs more than a successful result. It needs an explanation someone can inspect and trust.
We also learned that using a real machine-learning model does not automatically make its predictions suitable for a new problem. Our credit-card benchmark model demonstrates inference, but applying fraud detection to international institutional payments would require relevant data, careful validation, and domain expertise.
Above all, we learned to value the less glamorous work: checking response formats, testing state transitions, tracing errors, and making limitations visible. That work turned our idea into something we could demonstrate honestly.
What's next for Transnational
Our next step is to strengthen the foundation: fix the remaining interface mismatches, improve validation, and make payment-state transitions more reliable.
From there, we want to connect and verify a live Hyperledger Fabric workflow, validate the complete PayPal Sandbox funding journey, and test routing against more realistic liquidity scenarios.
Longer term, we want to explore relevant fraud data, stronger compliance integrations, role-based approvals, and clearer explanations for every decision.
The ambition is still the same as when we started: help people understand a payment’s journey, instead of simply hoping it reaches the other side.## What it does
How we built it
Challenges we ran into
Accomplishments that we're proud of
What we learned
What's next for Transnational
Built With
- ag-grid
- docker
- fabric-gatewaysdk
- fastapi
- go
- grpc
- hyperledgerfabric
- kubernetes
- networkx
- nex.js
- nextjs
- node.js
- or-tools
- pandas
- postgresql
- python
- react
- redis
- rest-api
- scikit-learn
- scoket.io
- tailwind
- typescript
- xgboost