Meshpay

Meshpay is rethinking financial inclusion by building an offline-first, payment network that works without Internet coverage.

Comment

Inspiration

After deep thoughts on deep tech approach we came up with something that became more heart driven than just the tech. Meshpay was born out of frustration and necessity. Deep beyond mere innovation we were inspired by compassion to solving a heartbeat problem of infrastructure breach.

What it does

Meshpay basically allows users to send and receive financial transactions in an offline-based way. Here I mean that the user needs no first-hand data connection or network infrastructure to carry out his or her financial needs.

How we built it

We built MeshPay by combining long-range LoRa communication, Wi-Fi access points, and a central gateway to simulate a decentralized, low-infrastructure financial transaction network. The system consists of:

  • Two ESP32 boards: Each acts as a LoRa node, with one functioning as a remote node and the other as a gateway.

  • Node-to-gateway communication: Nodes use LoRa to send requests to the gateway, which forwards them to a central processing unit (“the brain”) running on a local PC.

  • Brain (Backend Logic): The backend logic was developed in JavaScript for prototyping, designed to handle login, balance check, transactions, and name verification. It exposes API endpoints that the gateway can access via HTTP requests.

  • Local JSON Data Transmission: Since LoRa has low bandwidth, we adopted lightweight JSON files for transmitting data.

  • WebSocket Integration: Each ESP32 node handles a WebSocket connection for real-time updates from the node to the user’s app.

  • Prototype Deployment: For testing, we hosted the backend on a local machine, simulating the “brain” that processes all incoming requests.

We applied a first-principles approach, questioning every part of the system, reducing it to essential functions like authentication, communication, processing, and feedback, then rebuilding it to work offline with minimal dependencies.

Challenges we ran into

  • CORS and Cross-Origin Issues: When accessing API endpoints from the frontend running on a different port or IP, we frequently hit CORS policy blocks.

  • No Internet Authentication: In traditional systems, OTPs and email verification are used to verify users, but offline, we had to rethink how to verify identities without email.

  • Persistent WebSocket on ESP32: Maintaining a reliable WebSocket connection from a microcontroller (ESP32) was tricky, especially when dealing with simultaneous requests and updates.

  • JSON Size Optimization: With LoRa’s limited data rate, transmitting overly large JSON payloads resulted in delays or dropped packets.

  • Gateway Parsing: Parsing and validating JSON requests from LoRa on the gateway before passing to the brain was challenging to get right consistently.

  • User Experience Limitations: Without internet access, functions like “forgot password” or email-based registration required rethinking from the ground up.

Accomplishments that we're proud of

  • Decentralized Offline Transaction Architecture: We designed a complete payment communication system that can function with zero internet access between user and node.

  • Real-Time Feedback Over WebSocket from Microcontrollers: Establishing and maintaining persistent WebSocket communication on ESP32 devices was a major technical achievement.

  • Dynamic Node Communication Using LoRa: We successfully implemented long-range communication between distributed nodes and a gateway using LoRa.

  • First Principles Engineering: We didn’t just patch together APIs—we designed a system from scratch based on core problems, minimal assumptions, and a clean understanding of goals.

  • Scalability Vision: Though it’s a prototype, the system is built to scale into a full financial payment system in real-world deployments, with the gateway connected to a more powerful backend or cloud system.

What we learned

  • Constraint-based Design Forces Creativity: Working without internet forced us to rethink common UX flows like registration, reset password, and OTP.

  • LoRa is Powerful but Demands Simplicity: Its range is fantastic, but data must be tightly structured, compact, and efficiently parsed.

  • ESP32 is Capable Beyond Expectations: With WebSocket and Wi-Fi access point mode combined with LoRa, the ESP32 proved to be a versatile core for building edge nodes.

  • Security Needs New Thinking Offline: Without third-party email or SMS verification, user identity and authentication need to be handled differently, perhaps using local hardware tokens or face-to-face activation.

  • Communication Layer Must Be Modular: Separating transport (LoRa), gateway logic, and backend logic allowed for easier debugging and clear understanding of system flows.

What's next for Meshpay

  • API integrations with Paystack, Moniepoint, or Flutterwave
  • Integration with decentralized identity systems for KYC-less transactions

Built With

Share this project:

Updates