AWS Builder Center
80 Over 120: The Number That Should Have Scared Me

80 Over 120: The Number That Should Have Scared Me

A near-miss inside a personal health tracker and what it actually took to trust the number on screen. It started with a spreadsheet I never opened.

Cloud Infrastructure Engineer
I track seven things about my health
Blood pressure
Blood sugar
Fitness
PCOD
Hemoglobin
Uric acid
Thyroid.
Every single one lived somewhere different — a BP app here, a diabetes app there, cycle tracking in a third thing, lab results as PDFs buried in an email folder I'd have to search "hemoglobin" in just to find. I didn't have a health picture. I had five disconnected fragments and a vague sense that I should look at them together sometime.
So one evening I decided to just build the thing. One dashboard. Seven metrics. My data, my browser, no account, no server, nobody else quietly holding my thyroid results five years from now.
With an AI doing the heavy lifting on implementation, it came together fast — faster than I expected a real, usable app to come together. A form for each metric. Trend charts. A dashboard showing the latest reading and whether it was normal, elevated, or something to worry about. Blood pressure came first because I check it most and because the rules for "is this fine" are among the most well-defined in medicine: under 120 over 80 is good and there's a whole staged system — elevated, stage one, stage two, crisis for exactly how worried to be as the numbers climb.
I wrote the logic in about ten lines. Check if it's low first, then work up through the stages. Simple. I moved on to the next metric.

The Number That Should Have Scared Me

A few days later, testing before showing anyone, I typed in a value almost as a joke: systolic 80, diastolic 120 numbers in an order that doesn't really happen in a real reading, just to see what the app would do with something odd.
It said:
Low.
I stared at that for a second before it landed. A diastolic of 120 isn't "low" anything on a real clinical chart that number sits in the box labeled Hypertensive Crisis, next to instructions to seek emergency care. My status logic checked whether either number was below the low threshold before it checked whether either number was catastrophically high. So a systolic of 80 genuinely low, worth flagging was silently burying a diastolic reading that should have been the loudest thing on the screen.
I fixed the obvious part first check for the worst-case conditions before anything else, always. But sitting with it longer, I realized the ordering wasn't really the bug. The real bug was trusting that any two numbers a person types in will always make physiological sense together. Diastolic is never supposed to exceed systolic in a real reading. So I added a check for exactly that condition and when it's true, the app doesn't guess a category anymore. It just says Check reading and refuses to pretend it understands something contradictory.
That single test value changed how I tested everything after it — not "does this look right," but "what's the ugliest, most contradictory input I can throw at this, and does it still tell the truth?"

What That Kind of Scrutiny Turned Into

Once I started thinking that way, I stopped treating the app like a demo and started treating it like something a real person would actually depend on. That changed what "done" meant for every feature after it.
Medication tracking got a real daily schedule instead of a checkbox set your doses per day and the app builds today's list automatically, no re-entering anything. The dashboard got status logic that accounts for the fact that hemoglobin and uric acid have different normal ranges depending on sex, because a single "normal" number for everyone would just be wrong for half the people using it. Cycle tracking doesn't just log period dates it calculates your average cycle length, flags irregularity, and predicts your next one, because a list of dates isn't the same as understanding your own pattern.
And because the whole reason I built this was to actually use it before an appointment, I added a one-click doctor's report. Pick a date range, and it prints a clean summary across every metric, current medications included, instead of me trying to remember three months of numbers out loud in an exam room while a doctor waits.
It installs on a phone like a real app now, works offline, and backups are encrypted end-to-end — AES-256, keyed to a passphrase only I know because the one genuinely realistic way this data could ever leak isn't someone hacking a server that doesn't exist. It's an exported file ending up somewhere it shouldn't.

Where It Landed

Vitals is live now, tracking all seven things I set out to track, built and shipped faster than I've built anything comparable before with an AI doing the typing and me doing the part that actually matters: deciding what the app is allowed to get wrong, and making sure the answer is nothing important.
None of the individual pieces are dramatic on their own. But building something you actually intend to run your own numbers through has a way of making every shortcut feel personal. I wasn't debugging an abstract status function that night. I was deciding what the app would tell me, on some ordinary morning, about a number that matters. And I'd rather have caught that at 80 and 120, typed in as a joke, than at 3am, for real, with the app telling me everything was fine.

If You Poked Around Inside It

Open it up and here's what you'd actually find. Every metric gets its own dashboard tile showing the latest reading and a plain-language status — Normal, Elevated, High, whatever it is next to a trend chart and a full history you can edit because I wanted to see the shape of my numbers over months, not just the last one I typed in. The classifications behind those labels aren't guesses; hemoglobin and uric acid get sex-specific ranges instead of one number pretending to apply to everyone, and blood pressure and blood sugar follow the same staged clinical thresholds that made the "Low" bug so obviously wrong in the first place.
Cycle tracking turned into something closer to pattern recognition than a calendar — it watches your average cycle length, flags when something's irregular, and predicts your next one instead of just logging dates and leaving the math to you. Medications work the same way: set how many doses a day, and the app builds today's list on its own, no re-entering anything, with taken/skipped logging and a browser notification if the tab happens to be open when a dose is due.
And the reason any of this exists walking into an appointment with an answer instead of a guess — is the doctor's report. Pick a date range, and it prints a clean summary across all seven metrics plus current medications, so I'm handing over a page instead of reciting three months of numbers from memory while someone waits.

The Part Where There's No Backend

Here's the thing that made the "no server" promise more than a talking point: there genuinely isn't one. Vitals is a React 19 and TypeScript single-page app, built with Vite, styled with Tailwind, routed with React Router, charted with Recharts. That's the whole stack. No API, no database, no auth provider because there's nothing on the other end to authenticate to.
Every reading you enter goes straight into your browser's own  localStorage  — the same storage every website already has for it, just never asked to hold something this personal before. Offline support and the install-to-home-screen behavior come from  vite-plugin-pwa , which wraps the app in a service worker at build time so it keeps working on a subway with no signal, exactly when you're most likely to be squinting at a lab result. Deployment is Vercel, which is doing less than it sounds like — there's no backend for it to run, just static files it serves and a rewrite rule so client-side routing doesn't 404 on refresh.
The one place I reached past the standard library was encryption and even there I didn't reach far.  crypto.subtle  — the Web Crypto API every modern browser ships with does the actual work: PBKDF2 with 250,000 iterations turns your passphrase into a key, and AES-256-GCM encrypts the export with it. No crypto package, no dependency to audit for a supply-chain compromise, just the same primitives your browser already uses for HTTPS, pointed at a JSON blob instead. If someone gets hold of an exported backup without the passphrase, they get ciphertext. That's the whole security model, and it's small enough that I could actually reason about all of it.
Stack at a glance:
React 19 · TypeScript · Vite · Tailwind CSS v4 · React Router · Recharts · date-fns · vite-plugin-pwa · Web Crypto API (native) ·  localStorage  · Vercel for static hosting
It installs like a real app on your phone and works offline. And because your data lives only in your browser's  localStorage  — never on a server, because there isn't one — the one real way it could ever get exposed is an exported backup file landing somewhere it shouldn't. So even those are encrypted, AES-256-GCM, locked to a passphrase only you know. Lose the passphrase and the file is just noise.
Any opinions in this article are those of the individual author and may not reflect the opinions of AWS.
Enjoyed reading this content? Let the author know!

Your likes, comments, shares, and saves help creators reach more builders.

Loading recommendations

Loading article