Nota: A Real App in One Afternoon

Nota is an iPhone app that records a doctor visit, transcribes it on the phone, and turns it into a plain-language summary: what the doctor said, which of your questions got answered, and what happens next. An adult child sets it up and sees every summary. The parent presses one button.

It isn't live. There's no App Store listing and no launch date. I'm writing about it anyway because it's the best example I have of something I keep relearning: a real, well-built piece of software doesn't have to take months. Nota went from an empty repo to a merged iPhone app, a tested API, a homepage and a full marketing kit in one afternoon.

The problem

If you've ever managed a parent's care from another city, you know the phone call. "How'd the appointment go?" "Fine. He said it was fine." Which doctor? Did the dose change? Did anyone ask about the dizziness?

Patients forget a lot of what they hear in an appointment, and the person asking is often the one who wasn't in the room. I wanted a record of what the doctor actually said, written in plain language, that the whole family could trust and nobody else could read.

What I built

The parent's phone runs Simple Mode: one big apricot Start Visit button, the next appointment, and the questions the family wants asked. Tap the button, read a short script asking the doctor's permission, and put the phone in your pocket.

When the visit ends, the phone transcribes the audio and writes the summary on the device. Every line links back to the moment in the recording it came from, so you can hear the doctor say it yourself. The audio never leaves the phone.

Then the family side kicks in. Each question gets marked answered, partly answered or not addressed, and the unanswered ones carry over to the next visit. If the doctor changed a medication, it shows up as a suggested edit with the quote from the transcript. Nothing changes on the shared medication list until somebody taps to accept it.

A few rules I set early and never bent:

• Not a medical device. Nota reports what was said. It never diagnoses or suggests treatment, and every summary says it can contain mistakes.
• Consent, twice. The doctor is asked before every recording. Family members see nothing until the patient agrees on their own phone.
• Private for real. Only the patient and the family they invite can read their visits. Everything that syncs is end-to-end encrypted, so not even Nota's server can read it.

The afternoon

Here's the part I actually want to talk about. This is the repo's git history:

Two and a half hours from the first commit to the third merged pull request. Here's what landed in that time:

• A Railway API in TypeScript and Postgres. Sign in with Apple, email codes, passkeys, one-time invite codes for the parent's phone, care circles with consent, encrypted sync with per-device keys and key rotation, WebSocket updates, push notifications that carry no health details, and StoreKit 2 billing. It ships with 34 integration tests that run against a real Postgres in CI.
• A SwiftUI app for iOS 26. Simple Mode, crash-safe recording that keeps going when the phone locks, on-device transcription with SpeechAnalyzer, and a three-pass summary with Apple's on-device Foundation Models that checks every quote against the transcript. Plus the medication list with RxNorm search and pharmacy-label scanning, family invites with QR codes, Face ID lock, a paywall and a Siri shortcut. 94 Swift files.
• A marketing kit. App Store screenshots and listing copy, campaign ideas, a homepage served straight from the API, and a one-page flyer for care partners.

To be clear about what that afternoon was and wasn't: the hours before the first commit mattered. I walked in with a product spec and a brand system already written: the voice, the colors, the type, the rules about consent and medical advice. Then I built it with Claude Code, and the speed came from never having to stop and decide what Nota was. Every one of those decisions had already been made on paper.

Why it went fast

Write the spec like you mean it. A vague spec makes for a vague prototype. Mine said things like "Say 'visit,' not 'session'" and "Medication changes show up as suggested edits with the transcript quote." Specific rules turn into specific code.

Design first, in tokens. The brand guidelines came with design tokens: warm paper, Nota green, apricot only on Start Visit, Atkinson Hyperlegible for type. The app, the homepage, the screenshots and the flyer all read from the same values, so everything matched without anyone pushing pixels.

Pick boring infrastructure. Postgres, a Dockerfile and Railway. I didn't want to learn anything new about hosting that day. The interesting parts of Nota are on the phone.

Let the phone do the hard part. Transcription and summaries run on the device with Apple's own models. That made the privacy story simple, and it also cut out a whole AI backend I'd otherwise have had to build, secure and pay for.

Test what you can't eyeball. The UI you can look at. Encrypted sync, key rotation and consent rules you can't, so those are where the 34 integration tests went.

Small, reviewable merges. Three pull requests, each one done before the next started: the app and API, then the marketing kit and a demo mode, then the homepage. A review pass before the first merge caught compile issues in the services before they landed.

The architecture, on one screen

 Parent's iPhone (Simple Mode)                      Caregiver's iPhone
 ┌──────────────────────────────┐                   ┌──────────────────────────┐
 │ Start Visit → record (AAC)   │                   │ Summary, questions,      │
 │ SpeechAnalyzer → transcript  │                   │ medication list, family  │
 │ Foundation Models → summary  │                   │                          │
 │ CryptoKit: seal with circle  │                   │ CryptoKit: open with     │
 │ keys before upload           │                   │ circle keys              │
 └──────────────┬───────────────┘                   └─────────────┬────────────┘
                │      ciphertext + scope + key version           │
                └──────────────► Nota API on Railway ◄─────────────┘
                                 Postgres · WebSocket · APNs · App Store

The server knows who is in which family. It holds wrapped keys it can't open and encrypted records it can't read. Older iPhones without Apple Intelligence still record and transcribe, and a newer iPhone in the family writes the summary and syncs it back.

The marketing came along for free

Because the brand was already defined as tokens, the marketing didn't need its own design pass. The App Store screenshots come from the app's own layouts and copy with a made-up demo family (Walter, his daughter Sarah in Denver, Dr. Patel in cardiology), and the app has a demo mode with the same family for capturing the real thing. Same for the homepage and this flyer for care partners and senior-care organizations:

That's usually the stuff that drags a side project out for weeks after the code is "done." Here it was a single pull request.

What's left

Nota is a prototype. Before it could go live it needs real-device testing on iOS 26 (a few of the newest Apple APIs are marked // Verify: for the first Xcode build), App Store review, real screenshots in place of the rendered ones, and an attorney's eyes on the privacy policy. That's real work, and it's the kind you'd only want to do for an idea that has already earned it.

That's the point of building this way. An afternoon got me a version good enough to hold in my hand and judge honestly: the screens, the privacy model, the pricing, the pitch to a care partner. If I decide to take it the rest of the way, I'm starting from working software instead of a slide deck. If I don't, I lost an afternoon, not a quarter.

Chris