Skip to main content
Back to Projects

WalletX

All Systems Operational

Full-stack FinTech-style wallet demo: P2P transfers, balances, history, and dashboard analytics. MongoDB multi-document transactions enforce ACID semantics so debits and credits stay consistent under concurrency (simulated funds, not real money).

Tech stack

ReactTypeScriptTailwind CSSFramer MotionRechartsNode.jsExpress.jsMongoDBMongooseMongoDB transactionsJWTBCryptZod

Overview

WalletX is a full-stack FinTech-style application that simulates real-world wallet operations such as peer-to-peer transfers, balance management, and transaction history. The system is designed with strong consistency guarantees, ensuring that every transfer behaves like a real financial operation. At its core, WalletX leverages MongoDB multi-document transactions to enforce ACID properties. All transfers are executed atomically using database sessions, preventing partial updates, double spending, or inconsistent balances even under concurrent requests.

What it does

  • Executes peer-to-peer money transfers with atomic guarantees
  • Maintains consistent balances across sender and receiver accounts
  • Stores complete transaction history with audit trail
  • Provides real-time dashboard with balance and analytics
  • Implements secure authentication and user management

Technical breakdown

System architecture

Frontend is built with React + Vite using TypeScript, with TanStack Query for server state management and Recharts for analytics. The UI is component-driven with Tailwind and Radix, focusing on responsive and accessible FinTech-style design.

Ingestion and data layer

Backend follows an MVC architecture using Express and Mongoose. Core business logic is implemented in a transfer service that uses MongoDB sessions and multi-document transactions to ensure ACID compliance. JWT handles authentication, while Zod validates all inputs before execution.

Technical challenges

Ensuring atomic money transfers

A transfer involves debiting one account and crediting another. Without transactions, partial failures could corrupt balances. This was solved using MongoDB sessions and multi-document transactions to guarantee atomicity.

Preventing double spending

Concurrent requests or retries could result in duplicate transfers. The system enforces balance checks and executes all operations within a single transaction scope to maintain consistency.

Maintaining consistency under failure

Failures during transfer execution (server crash, validation error) must not leave the system in an invalid state. Transactions ensure automatic rollback on any failure before commit.

Keeping transactions performant

Long-running transactions can cause contention in MongoDB. Indexing and minimal query scope were used to keep transactions short and efficient.

Who it is for

Designed for developers and recruiters to demonstrate understanding of real-world financial system design, including transactional integrity, backend architecture, and secure full-stack application development.

Challenges

  • Ensuring atomic debit-credit operations
  • Preventing double spending in concurrent requests
  • Handling transaction rollback on failure
  • Keeping MongoDB transactions performant
  • Validating inputs before transactional execution
  • Maintaining consistency across multiple documents

Learnings

  • ACID is critical for financial systems
  • MongoDB transactions enable true atomicity
  • Idempotency prevents duplicate operations
  • Validation should happen before DB logic
  • Short transactions reduce contention
  • Backend correctness > frontend complexity

Related Projects

LighterPulse

LighterPulse

Analytics and exploration platform for the Lighter.xyz ecosystem, covering dashboards, a block explorer, exchange statistics, multi-venue funding comparison, and protocol announcements. Redis-backed caching and a split between live and cached data paths keep the UI responsive.

All Systems Operational
View Details
Lighter Liquidations

Lighter Liquidations

Backend service for Lighter.xyz that ingests perpetuals liquidation events over WebSockets, deduplicates noisy replay batches, aggregates notional USD into per-minute buckets in Upstash Redis, and serves a rolling 24 hour liquidation total over HTTP.

All Systems Operational
View Details
View All Projects