LedgerLens

• 

  Main Screen 1

• 

  Main Screen 2

• 

  Main Screen 3

• 

  Main Screen 4

• 

  Logo

Inspiration

LedgerLens was inspired by a real operational problem in high-volume digital businesses: transaction data moves fast, but fraud, abuse, payment anomalies, and risk signals often get reviewed too late. Gaming platforms, fintech apps, ecommerce marketplaces, and wallet systems all depend on transaction integrity. A single missed pattern can turn into chargebacks, bonus abuse, compliance exposure, or direct financial loss.

I wanted to build a B2B product that feels like something an operations, fraud, payments, or compliance team could actually use. Instead of another generic dashboard, LedgerLens focuses on the question operators care about most: what changed, what looks risky, and what evidence supports that finding?

What it does

LedgerLens is a transaction integrity and anomaly monitoring platform for high-volume digital businesses.

The app provides:

• A risk dashboard for monitoring transaction activity
• Event review for transaction-style data
• User and account risk views
• Findings that summarize suspicious or unusual behavior
• Evidence-backed reporting
• CSV/JSON-style ingest flow concepts
• Settings for organization controls, rules, API keys, audit/compliance, and database verification
• Amazon Aurora PostgreSQL verification through an in-app write test

LedgerLens is designed for B2B teams working in industries like gaming, fintech, ecommerce, and wallet infrastructure. These teams need to detect problems such as suspicious transaction patterns, bonus abuse, payment drift, duplicate activity, and abnormal user behavior before those problems become expensive.

How we built it

LedgerLens was built with Next.js, React, TypeScript, Tailwind CSS, shadcn/ui, Vercel, v0.app, Node.js, API Routes, SQL, Recharts, Lucide Icons, and Amazon Aurora PostgreSQL.

The product interface was created and refined with v0, then deployed through Vercel. The app uses a deterministic seeded dataset for the main demo experience so judges can reliably explore the dashboard, events, findings, reports, and settings without needing a live customer data feed.

For the database layer, I provisioned Amazon Aurora PostgreSQL in AWS RDS as the production database foundation. I added an in-app Aurora Write Test that verifies the deployed Vercel app can write to Aurora PostgreSQL. The test inserts a vercel-smoke-test row into the public.ledgerlens_connection_tests table, proving the live app can connect to and write into the AWS database.

The core product architecture separates the stable demo workflow from the production database foundation. That means judges can review the product without random data changes breaking the flow, while the Aurora verification panel proves the live database path works.

Amazon Aurora PostgreSQL integration

LedgerLens uses Amazon Aurora PostgreSQL as its production-ready relational database foundation.

Aurora is intended to support data such as:

• Organizations and tenants
• Monitored users/accounts
• Transaction events
• Risk findings
• Evidence records
• Reports
• Audit logs
• Detection rules and configuration

For this hackathon build, Aurora was provisioned in AWS RDS and verified from the deployed app. The in-app smoke test successfully wrote a row from Vercel into Aurora PostgreSQL, creating an end-to-end proof path:

Vercel deployed app → Next.js API route → Amazon Aurora PostgreSQL → proof table insert

This confirmed that LedgerLens is not only a frontend prototype, but also has a working AWS database integration path.

Challenges we ran into

The hardest part was connecting the deployed Vercel app to Aurora PostgreSQL while navigating AWS networking, security groups, public database access, IAM authentication, password authentication, route tables, and RDS connectivity settings.

The main challenge was that the database could work from inside AWS, but the deployed Vercel app still needed the correct public network path, database endpoint, environment variables, and security group rules to connect from outside the AWS VPC. Debugging that required separating several different failure modes:

• Authentication failures
• Missing or stale Vercel environment variables
• Old IAM-based connection logic
• Private network timeouts
• Security group rules
• Public internet access settings
• Database endpoint mismatches

Once the correct Aurora configuration, endpoint, route, and app environment variables were aligned, the deployed app successfully inserted a live proof row into Aurora PostgreSQL.

Another challenge was keeping the demo stable while still proving real database capability. I solved that by using deterministic seeded data for the main product demo and a separate Aurora Write Test for live database verification.

What we learned

I learned a lot about how Vercel, Next.js server routes, and Amazon Aurora PostgreSQL work together in a real deployment. I also learned how important it is to distinguish between a working database, a working local or CloudShell connection, and a working public deployed-app connection.

The project reinforced that B2B software needs more than a nice interface. It needs evidence, auditability, operational clarity, and trustworthy infrastructure. For LedgerLens, that meant making the product useful for business users while also proving that the backend database path could work in production.

Accomplishments that we're proud of

I am proud that LedgerLens feels like a real B2B SaaS product instead of just a hackathon mockup.

The final app includes:

• A polished dashboard
• Transaction and event monitoring flows
• Risk findings
• User/account review
• Report views
• Settings and compliance sections
• A database verification panel
• A successful deployed-app write into Amazon Aurora PostgreSQL

The biggest accomplishment was getting the end-to-end Aurora proof working from the live Vercel deployment. The app successfully wrote a vercel-smoke-test row into Aurora PostgreSQL, proving that the deployed product can connect to AWS Databases.

What's next for LedgerLens

Next steps for LedgerLens include replacing the seeded demo data with full live event ingestion, adding tenant-specific persistence, expanding anomaly detection rules, and supporting integrations for alerts, exports, and compliance workflows.

Future versions could include:

• Live API ingestion
• Customer-specific risk scoring
• Rule builder for fraud and compliance teams
• Webhook alerts
• Slack/email notifications
• Provider and payment processor integrations
• Audit-ready evidence exports
• Multi-tenant billing and onboarding
• Machine-learning-assisted anomaly detection

LedgerLens could become a monetizable B2B platform for companies that need better transaction integrity, fraud visibility, and operational risk monitoring without building an internal detection system from scratch.

Built With

• amazon-aurora-postgresql
• aws-databases
• aws-rds
• csv/json-event-ingestion
• lucide-icons
• next.js
• next.js-api-routes
• node.js
• react
• recharts
• risk
• rule-based-anomaly-detection
• shadcn/ui
• sql
• tailwind-css
• transaction
• typescript
• v0.app
• vercel