I’m currently building CozonPay, a fintech system under Cozon Digital World. It’s a wallet and payment platform designed to handle transfers, deposits, and withdrawals in a simple and reliable way.
I’m using Node.js, Supabase, React, and Monnify API for payment processing.
While building it, I’ve faced several technical challenges that changed how I think about backend systems, especially in fintech.
1. Payment API Reliability
One of the first challenges was working with payment APIs.
At first, I assumed once an API returns success, the transaction is complete. That was wrong.
In reality:
APIs can return success but still fail internally
Network delays can cause missing responses
Webhooks may arrive late or out of order
This taught me that API response ≠ final truth.
Now, every transaction must be verified from the backend before updating wallet balances.
2. Webhook Handling Complexity
Webhooks are critical in fintech systems, but they introduced new problems:
Duplicate webhook events
Delayed delivery
Missing events in rare cases
Out-of-order processing
If not handled properly, users can get incorrect balances.
To solve this, I had to design:
Idempotent webhook processing
Unique transaction IDs
Logging for every event received
This ensures that even if the same webhook arrives multiple times, it only processes once.
3. Wallet Balance Consistency
Maintaining accurate wallet balances is harder than it looks.
The biggest risks are:
Double crediting a user
Failed debit but successful credit
Race conditions during simultaneous requests
To fix this, I had to rethink the system:
Always calculate balance from transactions, not manual updates
Use atomic updates where possible
Log every wallet change
This reduced inconsistencies significantly.
4. Race Conditions in Transfers
When two transactions happen at the same time, things can break.
Example:
User sends money twice quickly
Both requests read the same balance
System allows overdraft or incorrect deduction
To handle this, I had to introduce:
Transaction locking logic
Sequential processing for wallet updates
Strict validation before deduction
This was one of the hardest problems so far.
5. Security and Trust Issues
Since CozonPay handles money, security is not optional.
Key lessons:
Never trust frontend data
Always validate transactions on the server
Protect API routes properly
Store sensitive keys securely
Even small security mistakes can lead to serious financial issues.
6. Error Handling and Logging
At the beginning, debugging was difficult because I didn’t have enough logs.
Now I’ve learned to:
Log every API request and response
Track transaction states (pending, success, failed)
Store webhook history
Monitor failed transactions separately
Without proper logging, fintech systems are impossible to maintain.
7. System Design Complexity
What started as a simple wallet system became a full backend architecture challenge.
I had to think about:
How money flows through the system
How to recover failed transactions
How to scale without breaking consistency
How to structure database tables properly
Fintech is less about coding features and more about designing trust systems.
Conclusion
Building CozonPay has shown me that fintech systems require a different mindset.
It’s not just about making features work—it’s about ensuring:
Accuracy
Reliability
Security
Consistency
I’m still building and improving the system step by step, but each challenge is making the architecture stronger.