mnemo

Write it, speak it, snap it. Mnemo turns every fleeting idea into a memory you can actually find later.

Comment

Inspiration

Ideas don’t arrive on schedule. They show up while walking, debugging, or halfway through a hackathon brainstorm — often as a half-written sentence, a voice memo, or a screenshot you’ll never find again.

I started with a voice-first “life logger” concept, but the real problem kept coming back to something simpler and more painful: I capture thoughts constantly, but I can’t retrieve them when I only remember the vibe, not the exact words.

Tools like iA Writer nail the writing experience. Voice memos nail frictionless capture. But neither helps when you’re searching for “that note about Aurora and v0” weeks later.

Mnemo is my answer: a private AI notebook for creators and coders. Capture thoughts in Markdown or a clean WYSIWYG editor, add local audio clips and images, hit save — and let the backend turn messy input into something you can actually find again.

What I learned

This project pushed me to think in local-first terms, not just “save to the cloud.”

Recording audio locally (without streaming while recording) taught me that capture UX and sync UX are different problems. Users shouldn’t lose work because they closed a tab or their connection dropped — so IndexedDB became the durability layer, with Aurora and S3 as the system of record once sync completes.

I also learned how much retrieval quality depends on metadata, not just raw text. A note isn’t useful if you can’t search transcripts, summaries, tags, and image descriptions together. That’s why the data model in Aurora PostgreSQL treats AI outputs as first-class searchable fields, not side effects.

On the infrastructure side, wiring Vercel + AWS OIDC + Aurora PostgreSQL + S3 was a crash course in modern serverless auth — especially getting IAM trust policies right so migrations and API routes could assume the right role per environment.

Finally, using v0 as a UI accelerator while keeping Vite + React as the real app taught me where AI scaffolding helps (mobile-first layouts, polish) and where you still need deliberate architecture (editor behavior, draft recovery, API boundaries).

How we built it

Mnemo is a mobile-first PWA built with Vite, React, React Query, and Context API, scaffolded with v0 and deployed on Vercel.

Capture layer (frontend)

iA Writer–style note editor with Markdown + WYSIWYG Local multi-clip audio recording (blobs stored in IndexedDB, not streamed during capture) Optional images stored as descriptions + lightweight thumbnails Explicit Save, plus local-first autosave on navigation, tab close, and app exit Recovery flow: unsaved drafts surface on the dashboard and sync when you’re back online Processing layer (Vercel Functions)

/api/notes — create and list notes /api/process — transcribe, summarize, tag, and enrich note metadata (AI pipeline) /api/search — retrieve notes by keyword across title, body, transcripts, summaries, tags, and image descriptions /api/media — serve private audio/image assets from S3 Storage layer (AWS)

Amazon Aurora PostgreSQL — notes, metadata, tags, transcripts, processing jobs, search index fields Amazon S3 (mnemo-user-media-*) — private audio clips and image assets SQL migrations run via a small Node migration runner against Aurora Data flow

User captures note locally (IndexedDB) → Save or autosave triggers sync → Vercel Functions write to Aurora + upload media to S3 → AI processing enriches the note → Search queries structured PostgreSQL data + AI metadata The architecture is intentionally MVP-shaped: synchronous processing first, with a clear path to async workers (SQS + Lambda) and semantic search (pgvector) as the product matures.

Challenges we faced

  1. Local-first capture without losing data The first version felt fine until you closed the tab without hitting Done. Fixing that meant always writing drafts to IndexedDB, marking sync_pending on pagehide, and only clearing local state after the backend confirms sync — plus a “Recovered unsaved note” card on the dashboard.

  2. Audio as blobs, not URLs Voice clips can’t be treated like text. Storing Blobs in IndexedDB, restoring object URLs on reopen, and uploading to S3 only after save required careful state management across the editor, draft store, and API client.

  3. v0 speed vs. real app architecture v0 gave us a polished mobile UI fast, but the hackathon stack needed Vite + Vercel Functions, not a Next.js-centric backend. We used v0 for visual scaffolding and wired the editor, persistence, and APIs manually.

  4. AWS auth across environments Connecting Aurora through Vercel’s AWS integration looked simple until local migrations failed on AssumeRoleWithWebIdentity. The fix was tightening IAM trust policies so the development environment could assume the database access role — a small config issue that ate hours.

  5. Search that matches how humans remember Exact keyword search is a starting point, not the end state. The harder product problem is matching vague memory (“that AWS database note from the hackathon”) to enriched metadata — which is why the schema and processing pipeline are designed around summaries, tags, and transcripts from day one.

Built With

Share this project:

Updates