Tamalife

Tamalife turns your subscriptions into living creatures. If you ignore renewals, price hikes, or wasteful spending, your garden withers making subscription management impossible to ignore.

Comment 1

Inspiration

It started with a $220 charge none of us remembered agreeing to.

One of us had signed up for a "free 7-day trial" months earlier, forgotten about it, and gotten quietly auto-renewed into a full annual plan. No warning email that landed, no reminder, just a line item on a bank statement. When we compared notes, everyone had a version of the same story: the gym membership after we stopped going, the streaming service we double-subscribed to, the "$2.99/mo" app that had crept up to $8.99 without anyone noticing.

The problem isn't that people are careless. It's that subscriptions are designed to be forgotten. They're invisible by default, the price changes are silent, and every existing "subscription tracker" is just another boring spreadsheet with a list of logos and dollar amounts, something you have to remember to open, which defeats the entire point.

We asked a different question: what if your subscriptions were impossible to ignore because they were alive? What if forgetting to deal with a renewal had a face a little creature that got visibly sick until you took care of it? That's Tamalife: a Tamagotchi for your money. Keep your expenses alive.

What it does

Tamalife turns your subscriptions into a cozy pixel-art garden of living creatures, one per subscription. Each creature's health mirrors the real financial state of that subscription:

  • A healthy subscription = a happy, breathing creature. Good value, no surprises, renewal far away.
  • A renewal approaching or a detected price hike = the creature gets concerned, then sick, then critical it droops, shivers, and its habitat darkens. You feel the neglect.
  • Resolving it (renew, cancel, snooze, or switch) = a rescue moment and the creature recovers.

Under the cozy surface is a real financial engine:

  • 📸 Receipt-to-creature hatching: snap a screenshot of a receipt or confirmation email and our extraction pipeline (OpenAI with a deterministic heuristic fallback) pulls out the merchant, plan, price, and renewal date, then "hatches" a new creature, no manual data entry.
  • 🔍 Price Intelligence: for each subscription we surface a verified provider match, real price history, active deals, and cheaper alternatives ranked by feature-match and switching effort each with a confidence score, so you can act with proof, not vibes.
  • 💡 Recommendations: plain-English "you could save $X/mo by switching or downgrading," with thumbs-up/down feedback that trains the system.
  • 🌗 A living dashboard: portfolio health score, level/streak progression, monthly and annual spend, and total saved-per-year, all wrapped in a day/night garden that re-themes the entire app.
  • 🔔 Renewal reminders so the $220 trial-turned-annual-plan never happens to you again.

How we built it

Frontend: a game engine disguised as a finance app. Tamalife is an Expo (SDK 54) / React Native 0.81 app on the New Architecture, with expo-router for file-based navigation and React 19. The creatures aren't static images, they're a procedural rendering system: SVG bodies (react-native-svg) layered with animated faces, particle systems, and dynamic shadows, all driven by Reanimated 4 worklets running on the UI thread so breathing, drooping, shivering, and "pop" reactions stay at 60fps. Mood-specific creatures use frame-based sprite sheets that swap by health state. State is managed with Zustand, auth with Clerk (@clerk/expo + secure-store token cache), and the whole thing is themed by a single day/night palette so one toggle re-skins every screen.

Backend: a production-grade, not a hackathon hack. A FastAPI service with fully async SQLAlchemy, Alembic migrations, and a SQLite→Postgres (Supabase) path. We didn't cut the corners that usually get cut: idempotency keys on mutations, request IDs threaded end-to-end, exponential-backoff retries with jitter on the client, a TrustedHost + CORS + custom security middleware stack, rate limiting on the expensive parse endpoint, structured logging (structlog), and Sentry. Clerk JWT verification, webhook-driven user lifecycle, and a privacy-first design where receipts live in scoped, private storage and no PII touches the logs.

Price Intelligence: the hard part. This is a safe, ethical scraping and verification pipeline: it discovers pricing sources, monitors them with strict guardrails (custom user-agent, connect/read/total timeouts, response-byte caps, redirect limits, per-source leasing so we never hammer a site), and publishes changes only after a review/verification step. Nothing reaches the user until it's confidence-scored — which is why deals are labeled and unverified data is clearly marked. The receipt extractor is provider-swappable (heuristic ↔ OpenAI) behind one interface.

The creature ↔ money bridge. A decay engine maps real financial signals (days-to-renewal, price-hike detection, health score) onto creature moods, and a portfolio module aggregates everything into the dashboard's health, level, and savings numbers.

Challenges we ran into

"Why won't it open on my phone?" the localhost trap. Our biggest debugging saga: the app ran perfectly in the browser but couldn't reach the backend on a physical phone, and never touched the database. The culprit was a stack of silent failures: the client pointed at http://localhost:8000 (which, on a phone, is the phone itself), the backend's TrustedHostMiddleware 400'd any LAN request, uvicorn was bound to 127.0.0.1 instead of 0.0.0.0, and Windows Firewall blocked the ports. We fixed it properly instead of hardcoding an IP: the client now auto-derives the API host from the Metro dev-server host at runtime, so any teammate's device just works regardless of network.

Expo Go vs. real push notifications. We added FCM push via React Native Firebase and instantly couldn't open the app in Expo Go on iOS, because those native modules require a custom development build. Learning to reason about the Expo Go ↔ dev-build boundary (and keeping dev clean of native-only modules so the core app stays instantly runnable) was a real architectural lesson.

Animation performance vs. legibility. A living, animated garden is gorgeous until you try to read a dollar amount on top of it. We fought to keep Reanimated worklets at 60fps while layering scrims and opaque card surfaces so financial data stays crisp over a busy, moving background beauty and readability, not one or the other.

Trustworthy data, not scraped noise. Showing a "cheaper alternative" that turns out to be wrong destroys trust instantly. Building the verification-and-confidence layer so we only surface data we can stand behind, and clearly label anything simulated took as much care as the scraping itself.

Integrating six branches under time pressure without turning main into a graveyard of merge conflicts taught us more about Git hygiene than any tutorial.

Accomplishments that we're proud of

  • A genuinely novel interaction model. We've never seen a finance app that makes you care about a subscription because a little creature is visibly suffering. The metaphor isn't decoration it's the product.
  • Backend that could actually ship. Idempotency, retries, request tracing, rate limiting, private storage, and a real migration path most hackathon backends are one print() away from production. Ours isn't.
  • A 60fps procedural creature system built from SVG + Reanimated worklets, not a canned animation library.
  • An ethical price-intelligence pipeline with guardrails and confidence scoring baked in from the start.
  • End-to-end polish: receipt → extraction → hatched creature → decaying health → verified savings → resolution, all working as one loop.

What we learned

  • Metaphor is a feature. Reframing "a list of subscriptions" as "a garden that needs you" changed every design decision downstream and it's what makes people remember the app.
  • The last 10% (device networking, encoding bugs, Expo Go boundaries, firewall) is where real apps are won or lost. Everyone can build a happy-path demo; making it run on a stranger's phone is the actual bar.
  • Async FastAPI + idempotency + tracing are learnable in a weekend and worth every hour reliability reads as quality.
  • Design systems scale you. One day/night palette and a shared component kit let us re-theme the entire app from a single toggle instead of touching 20 screens.
  • Trust is a UX layer. Confidence scores and honest labels ("simulated data") do more for credibility than any amount of polish.

What's next for Tamalife

  • Reminders that actually fire: ship the FCM push pipeline in a full development build so "Netflix renews in 2 days, review?" lands before you're charged.
  • Shareable Garden Recap cards: a one-tap, beautiful image of your garden + total saved this year a built-in growth loop.
  • A "What-if" savings simulator: toggle subscriptions off and watch your projected cost and your garden's health update live.
  • Creature evolution: keep a subscription healthy long enough and its creature levels up; neglect it and it dramatically withers real game progression tied to real financial habits.
  • One-tap cancel & switch assistant: go from "you're overpaying" to "done" without leaving the app.
  • Bank & email import to auto-populate the garden, and a duplicate/zombie-subscription detector to hunt down the ones you forgot you had.

Tamalife started because one forgotten charge cost us $220. If a friendly little creature getting sick saves the next person from the same mistake, it's done its job. Keep your expenses alive.

Built With

Share this project:

Updates