Inspiration

Every money app we've used is great at telling us what already went wrong. "Your balance is low." "Overdraft fee charged." Always after the loss.

We're students, and we kept doing the same dance. We'd set up a rule (move $200 to savings when I get paid, top up checking if it dips), feel responsible for about a week, and then a paycheck would land a day late or a random bill would show up. The rule that was supposed to protect us quietly made things worse by draining savings at the wrong moment. We realized we had never actually tested any of our rules.

Developers would never ship code that way. We write tests, and a compiler yells at us before anything breaks. So why not do that for money?

And honestly, budgeting feels like homework: spreadsheets, categories, guilt. We wanted something you'd open because it's fun to look at. Your money becomes water flowing through pipes into tanks, and you can watch a whole month play out and see exactly where it springs a leak.

That's the name, too. Liquidity is the money word for "can you cover what's due," and also the water word. Find the leak before the loss.

What it does

Liquiditi is a type-checker for your money. Write the rule. Watch it break. Then ship it.

  1. Write. Describe a rule in plain English ("move 20% of every paycheck to savings"). Gemini turns it into a small, strict money language. Nothing runs unless it compiles.
  2. Break. A solver hunts for the smallest bad month: the late paycheck and surprise expense that make your rule fail.
  3. Fix. It shows you exactly what happened, day by day, then proposes a fix and proves it works.
  4. Ship. The rules run against a real Capital One Nessie account, but only with a valid proof certificate. Edit a rule afterward and the certificate dies, and the run is refused.

Meet Maya

Maya is paid $1,100 on the 1st and 15th and pays $950 rent. She has three rules and one promise to herself:

rent:   on day 1 pay $950 to landlord from checking
topup:  when checking < 300 move up_to(200) from savings to checking
stash:  on deposit move 20% of deposit from checking to savings

invariant: checking >= 0 and savings >= 300

In a normal month everything looks perfect. But Liquiditi finds that if her Dec 1 paycheck comes one day late and she makes a $581 purchase on Nov 25, her savings end the day at $240, below her $300 safety floor. A $580 purchase is fine. One dollar is the difference.

We call that number the Resilience Radius: the biggest surprise expense a plan can absorb without breaking a rule.

$$R = \max{\, s \;:\; \text{no scenario with a surprise expense} \le s \text{ violates an invariant} \,}$$

Maya's radius is $580. Liquiditi finds a one-line fix, adding and savings >= 500 to the top-up rule, proves it, and her radius jumps to $880.

How Capital One's Nessie fits in

Nessie is where the idea meets a bank.

  • Seeding. We create a sandbox customer in Nessie with accounts and a transaction history that matches the persona, so the simulator and the bank start from the same balances.
  • Reproduce it in the bank. Once Liquiditi finds the failing month, one button replays those exact events (the late paycheck, the $581 purchase) as real Nessie transactions, so the broken balance shows up in an actual bank API, not just in our simulator. After applying the fix and replaying again, Maya's savings stay above her floor.
  • Reconciliation. We compare the simulator's balances to Nessie's, day by day, and show a RECONCILED or DRIFT badge. If our model ever disagrees with the bank, we say so.
  • Safe execution. Transfers are planned first, then committed, with deterministic transfer IDs so a crash and retry can never double-spend. Nothing runs without a certificate that matches the exact program.

How Tiger Data fits in

Verification produces a lot of numbers, and Tiger Data (TimescaleDB) is where they live.

  • Hypertables store every simulated day (balance_ticks), every engine call (verify_runs), and the write-ahead log (wal_entries), with a compression policy on the big table.
  • Continuous aggregates (envelope_daily, radius_history) turn millions of rows into a risk envelope: the p01 / p50 / p99 balance across 5,000 simulated futures for every day of the month. That's the fan chart you see in the app.
  • It's fast where it counts. The daily envelope over 600k rows took 1,467 ms in raw SQL and 31.6 ms from the continuous aggregate, about 46x faster. We loaded about 1.2M rows into the service during testing.
  • Proof vs. sampling, with data. A 5,000-scenario random search put Maya's smallest violating purchase at $580.06 (the exact answer is $580.01). After the fix, sampling said $881.23 while the exact answer is $880.01. Sampling overstates how safe you are. The proof doesn't.
  • Radius history. Every time you edit a rule, the Resilience Radius is stored, so you can see your plan get stronger over time.

How we built it

  • A tiny money language and a pure simulator. Everything is integer cents and event-sourced. Each day, outside events (paychecks, bills, purchases) apply first, then rules fire in order until nothing changes. The same inputs always give the same month.
  • A real solver. We encoded the simulator's semantics into Z3 (an SMT solver) over a bounded horizon. If the solver says UNSAT, the rule is proved safe within the stated assumptions. If it finds a counterexample, we shrink it to the smallest one. A fast-check search is the fallback and a cross-check.
  • Translation validation. Every counterexample the solver produces is replayed in the plain simulator. If they disagree, we treat it as an encoding bug and never show it to the user.
  • Auto-repair. A counterexample-guided loop generates small candidate edits (extra guards, lower caps, new thresholds), rejects the bad ones, and proves the winner.
  • Proof-carrying execution. A certificate (hash of the program, hash of the assumptions, solver version) is required to run anything. A hash-chained write-ahead log makes tampering detectable and crashes recoverable.
  • The part you see. React and three.js: glass tanks, chrome pipes, and a failure moment where the screen slows down, the light floods red, and the tank drains. All of it is driven by the same event log the engine produces.
  • Gemini translates English into rules. It only proposes. The deterministic checker decides.
  • Hosting on Vultr, with our domain through GoDaddy Registry.

The LLM proposes. The compiler disposes.

Challenges we ran into

  • Making the proof fast. Our first Z3 encoding took about 25 seconds to prove Maya's rules. Choosing the paycheck delay before the purchase amount got it under a second.
  • Not trusting our own solver. A bug in the encoding would give confident, wrong answers, which is the worst kind of bug for a money tool. That's why every counterexample is replayed in the simulator.
  • Being honest about "proved". Our proofs only hold inside the assumptions we state (which paychecks can slip, which bills can vary). The app shows those bounds, and a solver timeout says "unknown", never "proved".
  • Money has messy semantics. What happens first on a day? Can a rule fire twice? What if two rules fight each other forever? We had to pin all of that down.
  • Getting the bank and the simulator to agree. Nessie's dates, descriptions, and sandbox behavior don't always match a clean model, so reconciliation became a feature, not an afterthought.
  • 3D that helps instead of getting in the way. Our first interface had letters clipping through pipes, labels everywhere, and menus tucked in corners. We rebuilt it so the scene is the star and the features are obvious.
  • Making it not feel like a chore. That was the hardest design problem, and we're still not done.

Accomplishments that we're proud of

  • Finding the exact $581 tipping point with a solver, proving the fix, and showing the Resilience Radius go from $580 to $880.
  • A runtime that refuses to run an unverified rule, with a tamper-evident log.
  • Over 90 passing tests across the engine and the Tiger Data layer, including a property test that checks the solver's encoding against the simulator.
  • A risk envelope built from millions of simulated rows that comes back in about 30 ms.
  • Money that you can actually watch, which makes checking your finances feel less like homework.

What we learned

  • Ideas from compilers (type checking, counterexample shrinking, certificates) translate surprisingly well to personal finance.
  • A solver is only as trustworthy as the checks around it.
  • The most useful thing a money tool can say is "here's the exact day this breaks" rather than a pie chart.
  • Time-series databases make "what could happen?" cheap to answer.
  • Honest limits (synthetic data, bounded assumptions) make a project more credible, not less.

What's next for Liquiditi

  • Wider assumptions: more bills, more income sources, varying paydays.
  • Real bank integration beyond the Nessie sandbox.
  • Shareable replays, so you can send a friend the exact month that broke your plan.
  • Rule templates for gig workers and students with irregular income.
  • A mobile version with haptics for the failure moment.

Limitations: the demo uses Capital One's synthetic sandbox data, proofs hold only within the stated assumptions, and a production version would need a real bank integration.

Built With

Share this project:

Updates

Submission history