I Built a Pet Health App in Two Weeks Because My Notebook Failed Me

I was keeping a notebook to track health data for my three dogs.

For about two weeks, it worked. Then I needed to find a pattern in Maya's energy levels and the notebook turned into a pile of inconsistent entries I couldn't read or share or filter in any useful way. That, combined with an incident where I took my mom's dog to the vet and couldn't answer a single question about her history, pushed me to just build the thing.

Two weeks later, Pawformance was running in production. Here's how I built it and what I learned.

The Stack

Frontend: Lovable
Backend: Supabase (auth, database, real-time)
Payments: Stripe
Analytics: PostHog
Error tracking: Sentry
Uptime monitoring: BetterStack

The Lovable and Supabase combination is what made the two-week timeline possible. Lovable handles UI scaffolding fast. Supabase removes the need to build auth, manage database infrastructure, or set up API layers from scratch. Together they let me stay focused on the data model and the product logic rather than the plumbing.

The Data Model

This took the most thought. Here's the core structure:

users (handled by Supabase auth)

pets

• id, user_id, name, species, breed, birthdate, weight, photo_url, created_at

health_events

• id, pet_id, user_id, event_type (visit / symptom / observation), title, notes, date, created_at

medications

• id, pet_id, user_id, name, dosage, frequency, start_date, end_date, notes, active

vaccinations

• id, pet_id, user_id, vaccine_name, administered_date, next_due_date, administered_by

weight_logs

• id, pet_id, user_id, weight_lbs, logged_at

activity_logs

• id, pet_id, user_id, activity_type, duration_minutes, notes, logged_at

Everything scopes to user_id and pet_id. Supabase Row Level Security policies enforce this at the database level so a user can only read and write their own records. For the multi-pet dashboard, queries join across pets where user_id matches. No duplication, just proper relational structure.

The shareable vet report queries across all these tables for a given pet and generates a structured output. That was the original reason I started building. If I had had this when I took my mom's dog to the vet, I could have answered every question the vet asked.

Payments: Stripe and Three Tiers

Three tiers:

• Free: single pet, core logging
• $3.99/mo: unlimited pets, medication reminders, vaccination scheduling
• $7.99/mo: everything in $3.99 plus AI symptom checker, shareable vet reports, weight trends, multi-pet dashboard

Stripe Checkout handles the subscription flow. Supabase stores the subscription tier on the user record and the frontend gates features based on that value. The 14-day trial is set at the Stripe level so it applies automatically without extra logic on my end.

The integration was straightforward. The main thing I'd do differently: build the billing portal link into the app earlier. I added it later than I should have and it created unnecessary friction for testing the upgrade flow.

Observability: PostHog, Sentry, BetterStack

PostHog handles product analytics. I track key events: pet created, health event logged, report generated, upgrade initiated. With 8 users and 22 pageviews per week, the event volume is low, but the data is already showing me where people drop off in the onboarding flow.

Sentry catches errors in production. I integrated it early and it's caught a handful of things I wouldn't have found otherwise. One malformed date input that broke the weight chart. One edge case in the medication reminder logic where end_date being null caused a render error. Small things, but the kind that erode trust fast if they surface repeatedly to users.

BetterStack monitors uptime. Pawformance is not handling any level of traffic where downtime is a crisis, but the habit of monitoring matters. It also sends alerts if the Supabase instance or any external service dependency goes down.

What Worked

The Lovable and Supabase combination delivered on the two-week timeline. I was in production with auth, multi-pet support, full logging, and a working report before I'd spent a month on this.

Row Level Security in Supabase is the right way to handle per-user data scoping. Setting it up at the database level means I don't have to trust that every query in the application code has the right filters. The policy enforces it regardless.

PostHog session recordings have been more useful than I expected at this traffic level. Watching how the two or three active users actually move through the app told me things I couldn't have inferred from the event data alone.

What I'd Change

The data model for health_events is a little too flat. I used a single event_type field to distinguish between vet visits, symptoms, and general observations. That worked fine until I wanted to add structured fields specific to vet visits (like vet name, clinic, and cost). I ended up adding those as optional columns on health_events, which is fine but not clean. I'd probably split this into separate tables for vet_visits and observations with a shared parent structure.

I also built the free tier too generously in one specific way: the core logging experience is complete on free. That's intentional from a product philosophy standpoint, but it means the upgrade motivation is mostly about power users who have multiple pets or need the report. I'm comfortable with that trade-off, but I should have stress-tested the conversion logic before launch rather than after.

Current Numbers

• Users: 8
• Revenue: $0
• Pageviews per week: 22
• Months since launch: several

I built this and then essentially didn't promote it. The numbers reflect that. The app works, the infrastructure is solid, and I'm now actually starting to put it in front of people.

If you're a dog owner who has ever tried to track health data in a notebook and watched that system fall apart, or if you've stood in a vet's exam room and realized you couldn't answer basic questions about your pet's history, the free tier is a good place to start.

pawformance.app

Happy to answer questions about any of the technical decisions in the comments. The Supabase RLS setup and the Stripe trial logic are the two things people usually want to dig into.