Cross-Border
Transfer Engine

Modelling corridor NGN → KES
Prototype

A wallet is the easy half

A cross-border financial product cannot just be a wallet UI. Behind a single transfer sit multiple currencies, exchange rates, payment corridors, KYC, risk controls, provider routing, settlement, reconciliation and auditability.

That system — not the screen — is the actual engineering problem. It was built to model that honestly, end to end, before a single real rail is connected.

Both halves of the product

The customer app: a local-currency-first wallet, with USD, EUR, GBP and CNY alongside it. Add money, withdraw, send, receive, exchange, transfer across borders, and read the history of all of it. A visitor in Lagos sees naira first — not dollars converted for them.

The operational console behind it: customer operations, KYC review, AML and fraud, reconciliation, countries, fees and limits, and an audit trail. One system, two surfaces — because in a real financial product neither one works without the other.

What actually happens to a transfer

Country

54 modelled

Wallet

multi-currency

Currency

display vs actual

Exchange

real conversion

Transfer

cross-border

Verification

KYC / risk

Provider

routing

Settlement

simulated

Reconciliation

ledger match

Complete

audited

Where the thinking went

  • Display currency ≠ exchange — switching what a balance is displayed in is a viewing change, not a financial transaction. Actual conversion lives only in the Exchange flow. Collapsing the two is the classic way a wallet quietly lies to its user.
  • 54-country data model — each country carries its flag, ISO code, local currency and symbol, dialing code, payment methods, payout partner and corridor status — so visibility and live connectivity are separate facts, never conflated.
  • Multi-currency ledger — balances are modelled per currency rather than converted into one base at rest, which is what keeps the exchange path honest.
  • Provider abstraction — routing sits behind one interface, so a corridor's payout partner is configuration rather than a branch in the transfer code.
  • Passport KYC as state transitions — verification is a state machine with reviewable transitions, not a boolean — which is what makes the review queue in the console possible at all.
  • Append-only audit trail — operational actions are written, never edited. Reconciliation reads that record rather than the mutable state.

Verified prototype figures

0

Countries modelled

0

Phase-1 corridors

0

Screens / flows

0

Verification checks

A prototype, stated plainly

Simulated, not live

External financial systems are simulated. No real money moves. There is no live banking, payment processing, KYC, sanctions screening, AML or settlement behind this.

Stateful, not static

It is clickable and it remembers: balances, transfers, KYC states and operational actions persist across the flows the way they would in the real product.

Two real surfaces

The customer app and the admin console are both built, not mocked — the console reviews the same records the app creates.

Visibility ≠ connectivity

All 54 countries are modelled. Thirteen are Phase-1 corridors. The prototype never pretends those are the same number.

What production would add

Rails

Real payment gateway integrations, and live banking and settlement rails behind the corridors already modelled.

Compliance

Production identity and KYC providers, with actual AML and sanctions screening in place of the simulated checks.

Platform

A React and TypeScript production implementation on a real API backend, carrying the same models this prototype proved out.

01 — Documentation

README

Complete project documentation.

02 — Source

Open Repository

Public source code on GitHub.

The prototype, both surfaces, in full.

Tech Stack

Interface

HTML, CSS

Logic

JavaScript

Structure

Modular screens, hash routing

Charts

Hand-built SVG

Tooling

Python build & test

Building cross-border financial infrastructure?

The wallet is the easy half. Let's talk about the system beneath it.