All projects

Case study

I wanted to understand my money without handing over my bank login

Inunity is my attempt to bring transactions, cashflow and financial decisions into one system, while keeping data ownership clear.

Next.jsTypeScriptPostgreSQLPrismaClerkVercel

The short version

The problem, the build, and the proof

Full-stack product · Financial data · Privacy boundaries

The problem

Transactions and bills arrive from different sources, but collecting more data should not require sharing bank passwords.

What I built

A financial ledger and capture workflows for collecting, interpreting, and connecting purchase information.

The hard part

Incomplete observations, ambiguous currencies, and similar-looking purchases require conservative reconciliation.

How the pieces fit

A simplified path through the system. Follow the code links below for the details.

  1. 1Receive a user-controlled capture
  2. 2Validate the original observation
  3. 3Keep source evidence
  4. 4Match purchases conservatively
  5. 5Build usable financial views

Check the evidence yourself

Live productExplore Inunity's public website
Wallet capture validationRead the payload parser and constraintsPrivate repo — Inunity handles real financial data. Walkthrough available on request.
Capture contract testsSee currency and incomplete-event casesPrivate repo — Inunity handles real financial data. Walkthrough available on request.
Purchase matching testsInspect exact, possible, and rejected matchesPrivate repo — Inunity handles real financial data. Walkthrough available on request.

Evidence note: Public tests and source show design decisions; they are not a third-party security audit. Connections to other financial tools are evolving, not all completed integrations.

I got tired of financial information being scattered everywhere.

One app showed a balance. Another had my receipts. Bills lived in email. And understanding what I could actually spend meant putting the pieces together myself.

I wanted one place that could give me a clearer picture.

But there was a catch. I didn't want to build that picture by asking people to hand over their bank credentials.

That became the starting point for Inunity.

If you only have two minutes

Inunity is about making scattered financial information more useful without treating a bank password as the price of entry. Start with a transaction capture, keep the original observation, and reconcile it carefully before it changes a financial picture.

The live site shows the product direction. The wallet-payload tests and purchase-matching tests above show the decisions underneath. They are stronger evidence of the design than a dashboard screenshot would be.

Start with the information you can collect responsibly

Instead of relying on a bank-login scraper, I explored using the tools people already have on their devices.

One workflow uses an iPhone automation to send certain Apple Pay transaction details into an authenticated ledger. Another brings in financial records through user-controlled imports and connected workflows.

The goal is simple: understand transactions without asking for unnecessary access.

It also creates real engineering problems. A transaction can arrive late, arrive twice or have incomplete information. A refund is different from a new purchase. Currency conversions need dates and rates, not guesses.

Those details matter more to me than making a dashboard look impressive.

The ledger is the foundation

I built the backend around PostgreSQL and Prisma, with clear data ownership and authenticated access.

Once transactions have a consistent shape, they can support a wider set of useful views: recurring bills, cashflow forecasts, currency conversions, receipts and account history.

I also started exploring how specialized tools could connect to Inunity. PickMe works on the decision before a purchase. Looply looks at receipts, renewals and returns after a purchase. MarketLens handles market prices independently of a person's accounts.

I like that separation. Each tool can solve a focused problem without forcing everything into one enormous codebase.

Some of those cross-product connections are still evolving, so I distinguish the intended architecture from what has been verified end to end.

The difference between a match and a guess

Suppose a Wallet automation captures a $6.42 purchase, and an email receipt arrives later. Did those two sources see the same coffee, or did somebody buy two coffees?

The public matching code doesn't assume that amount and time are enough. It checks currency compatibility, a bounded time window, and merchant evidence. When the amount and time fit but the merchant does not, the matcher calls it a possible match rather than pretending it is certain.

The capture parser has another job: keep bad or incomplete observations distinguishable from valid ones. A currency label that cannot be decoded should not silently turn into a confident amount.

These are small rules with big consequences. If a finance app merges two different purchases, the dashboard can look tidy while being wrong.

Privacy is an engineering decision

Financial software deals with sensitive information. I don't think “secure” should just be a badge on the homepage.

That means limiting what gets collected, protecting private attachments, keeping customer data isolated, and making it possible to inspect how a record entered the system.

It also means being careful about claims. A system that doesn't request bank passwords still needs strong security and a clear explanation of its data flows.

The lesson I keep coming back to

I could have started by adding charts.

Instead, I kept coming back to the harder question: can I trust the information behind the chart?

The more I work on financial software, the more I see that a useful interface depends on very ordinary things being correct: dates, identities, amounts, retries, and who is allowed to change what.

That's the part of Inunity I find most interesting.

Explore Inunity · How an iPhone shortcut became a transaction feed