DEV Community: Uttam Kumar

🕵️ Money Detective

Uttam Kumar — Sun, 04 Oct 2026 17:39:45 +0000

Your Spending Has Clues. We Investigate Them.
What I Built
A friend once told me:
“I earn money every month, but somehow I don't know where it all goes.”

That sounded less like a budgeting problem and more like an investigation.

So I built Money Detective — an open-source AI-powered spending investigator that analyzes transaction history and looks for unusual patterns, spending leaks, recurring habits, and areas where money could potentially be saved.

Instead of simply showing another collection of charts, Money Detective tries to answer:
“What is actually happening with my money?”
You can upload a transaction CSV, and Money Detective:

📊 Analyzes your spending
🔎 Detects spending patterns and potential leaks
🧮 Calculates the underlying numbers deterministically
🤖 Uses an open-weight AI model to interpret the findings
💬 Lets you ask questions about your spending
🔐 Keeps the AI workflow local when running the full version with Ollama

The idea is simple:
Pandas finds the evidence. The open-source AI explains the evidence.

🚀 Try It
Live Demo:
👉 https://money-detective-omega.vercel.app/
The app also includes Try Demo Data, so you can explore the investigation without uploading your own financial information.

💻 Code
GitHub:
👉 https://github.com/uttamofficial/Money-Detective
If your actual repository URL is different, replace the link above.

How I Built It
The project uses a combination of deterministic data analysis and open-source AI.
Frontend

Next.js
TypeScript
Tailwind CSS
Recharts Backend
FastAPI
Python
Pandas
NumPy AI
Ollama
Qwen2.5 3B
Open-weight/local inference Architecture Transaction CSV ↓ Python / Pandas ↓ Data Cleaning & Categorization ↓ Spending Analytics ↓ Pattern Detection ↓ Structured Evidence ↓ Open-Weight AI ↓ Money Detective ↓ Human-Friendly Investigation

A deliberate design decision was to not let the LLM calculate financial facts from scratch.
The Python analytics layer calculates the numbers first. The AI receives those structured findings and focuses on interpreting and explaining them.
This makes the system much easier to ground and verify.

🤖 Why Open Innovation Matters
Financial data is sensitive.
I didn't want the core experience to depend on sending someone's transaction history to a proprietary AI API.
Money Detective uses Ollama + an open-weight model for the AI investigation layer, allowing the complete AI workflow to run locally.
That means the model can be changed without redesigning the application.
For example:
Qwen2.5 3B
↓
├── another Qwen model
├── Gemma
├── Llama
└── another compatible open model

The application isn't locked to a single AI provider.
That's one of the things I really liked about building this with open-source AI.

🔍 What Makes It Different?
There are already hundreds of budgeting and expense-tracking applications.
I wasn't trying to build another one.
The idea behind Money Detective is:
Don't just show me where I spent money. Investigate why my spending looks the way it does.

For example, instead of simply displaying:
Dining — ₹12,400
the investigation layer can identify patterns and turn the underlying analytics into a more useful explanation.
The goal is to make financial data feel more like an investigation than a spreadsheet.

🧠 What I Learned
The biggest lesson from this project was:
Don't use an LLM for everything.
For financial data, calculations should be deterministic.
Things like:

totals
averages
percentages
category spending
transaction counts
date ranges

are better handled by Python.
Then the AI can focus on what it is good at:
understanding patterns, reasoning over structured evidence, and explaining findings in a human-friendly way.
That separation made the application more reliable and also made it easier to validate the AI's responses.

👨‍💻 Built for a Friend
The original problem came from a simple conversation with a friend who struggled to understand where their monthly money was going.
Instead of building something only for myself, I wanted to turn that real problem into a small open-source product that someone could actually use.

My friend's reaction:
“I liked that it didn't just show me where I spent money. It actually helped me understand some of my spending patterns and where I could potentially save.”

I intentionally want to keep this part genuine rather than inventing a reaction for the submission.

🛠️ Built With
Next.js · TypeScript · Tailwind CSS · FastAPI · Python · Pandas · NumPy · Recharts · Ollama · Qwen2.5

🔐 Privacy by Design
The full local setup is designed around keeping financial information local.

No proprietary AI API is required for the core AI investigation.
The production demo also includes a graceful fallback because Ollama itself cannot run directly inside the Vercel deployment environment.

❤️ Why I Built This
I wanted to build something small, useful, and actually connected to a real person's problem.

Not another generic AI chatbot.
Not another expense dashboard.

A little detective for your money.
Your spending has clues. We investigate them. 🕵️

What If Your Documentation Could Argue With Itself? Meet TruthLayer.

Uttam Kumar — Sat, 03 Oct 2026 11:14:51 +0000

This is a submission for the Sanity Challenge, Path Two: Vibe-Code Something Strange.

What I Built

What if your documentation could check itself for contradictions?

That was the idea behind TruthLayer.

As documentation grows, information can quietly drift apart. One page might say an API supports 100 requests per minute, while another says 500. Both pages look perfectly fine on their own — until someone has to decide which one to trust.

TruthLayer is an AI-powered knowledge health system built with Next.js and Sanity that looks for these inconsistencies across structured documentation.

When it finds a potential conflict, it doesn't automatically rewrite anything. Instead, it creates a structured conflict in Sanity and sends it to a human review workflow.

The flow is simple:

Sanity Content → AI Analysis → Conflict Detection → Human Review → Resolution

This makes TruthLayer less like an AI writer and more like a spell-checker for organizational knowledge.

Demo

🚀 Live Demo:

https://truth-layer-five.vercel.app/

The live application includes:

• Knowledge Health Dashboard
• Document Browser
• Conflict Detection
• Conflict Inspection
• Human Review Workflow
• Approve / Reject / Investigate actions

Code

GitHub Repository:

https://github.com/uttamofficial/truth-layer

Built with Next.js, TypeScript, and Sanity.

My Build Process

I built TruthLayer using Google Antigravity.

I started with the core idea and used the coding agent to turn it into a working product — from the Sanity schemas and frontend to the AI analysis API and review workflow.

The Sanity content model is centered around three types:

• knowledgeDocument — the actual documentation
• contentConflict — detected inconsistencies
• review — human decisions about those conflicts

One interesting part of the build was the review workflow.

The first version could display review actions, but I wanted those actions to actually affect the underlying Sanity data. I iterated on the implementation until approving, rejecting, or investigating a conflict became a real workflow rather than just UI buttons.

I also tested the production build, Sanity connectivity, conflict detection, and review transitions.

The biggest takeaway from vibe-coding this project:

Getting an AI-generated app to compile is easy. Getting the workflow to actually make sense requires testing, breaking things, and giving the agent better instructions.

Sanity Project Details

Project ID:

YOUR_SANITY_PROJECT_ID = NEXT_PUBLIC_SANITY_PROJECT_ID

Dataset:

production

Main schemas:

• knowledgeDocument
• contentConflict
• review

Sanity isn't just being used as a database here. It holds the documentation, detected conflicts, and human review decisions as structured content.

Agent Session

Built and iterated using Google Antigravity.

I used the coding agent for scaffolding, Sanity schema creation, UI development, AI integration, workflow implementation, debugging, and production testing.

I don't currently have a suitable public Agent Session transcript to share.

Why TruthLayer?

Documentation rarely becomes wrong all at once.

It becomes wrong one outdated page at a time.

TruthLayer explores a simple idea:

What if we could detect those inconsistencies before someone discovers them the hard way?

That's the problem I wanted to explore with Sanity.

A few alternative titles

If you want something even more attention-grabbing:

What If Your Documentation Could Argue With Itself? Meet TruthLayer.
I Built an AI That Checks Whether Your Docs Agree With Each Other
Your Docs Are Lying to You. TruthLayer Wants to Know Why.
I Gave Sanity a Memory — Now It Can Find Contradictions
When Your Docs Disagree, Who's Right? I Built TruthLayer.
I Vibe-Coded a Spell-Checker for Organizational Knowledge
Your Documentation Has Contradictions. This AI Finds Them.

My pick: “What If Your Documentation Could Argue With Itself? Meet TruthLayer.”