Laterloom

"Seal today. Open tomorrow.

Comment

Inspiration

Some messages aren't meant for right now.

A letter to your child on their 18th birthday. A note to your future self before a big life change. A message from your whole friend group, sealed on graduation day and opened a decade later.

We kept thinking about how many of those messages never get written — not because people don't want to write them, but because there's no easy, reliable place to put them. Handwritten letters get lost. Hard drives fail. Social media posts disappear into feeds.

Laterloom started as a question: what if you could write it today, seal it, and have it arrive exactly when it should?

The name came from that same idea. The original name — Vaultly — felt too cold. A vault is where you lock things away and forget them. A loom weaves things together across time. Later + loom: something that takes shape slowly, arriving on the horizon exactly when it's meant to.

What it does

Laterloom is a time capsule web app that lets you seal memories today and deliver them to the future.

  • Create a capsule — write a message, add photos or videos, set an unlock date (1 year, 5 years, or any specific date)
  • Add recipients — send the capsule to yourself, loved ones, or a group; they're notified when it unlocks
  • AI Memory Enhancer — an AI assistant that asks meaningful questions and helps you find the right words when you're stuck
  • Collaborative capsules — share a contribute link so friends and family can add their own messages before the capsule seals
  • Multilingual — full UI and AI output in English, Japanese, Chinese (Simplified), and Vietnamese, switchable without page reload
  • Freemium model — Free (3 capsules), Personal ($5/mo, unlimited), Family ($15/mo, shared vault, up to 6 members)
  • PWA — installable on iOS and Android home screens

How we built it

The project runs entirely on the Vercel + AWS stack the hackathon was designed for.

UI scaffolding with v0: We used v0 by Vercel (https://v0.dev) to design and generate the initial component structure — going from concept to a working dark-themed interface in hours. This let us focus engineering time on the backend logic and AI integration rather than starting from blank CSS.

Frontend: Next.js 16 App Router with React Server Components, TypeScript, Tailwind CSS. The dashboard layout wraps all authenticated pages with a LanguageProvider context that handles i18n client-side for instant language switching.

Database: Amazon Aurora DSQL via Prisma ORM. We chose Aurora DSQL specifically for its ACID-compliant distributed transactions — a time capsule service needs the guarantee that a message written today will exist, unmodified, years from now. Aurora DSQL's serverless architecture also means zero infrastructure management.

Capsule unlock delivery: Vercel Cron Jobs run on a schedule to check for capsules whose unlocksAt date has passed and flip their status — triggering email notification to recipients.

AI: Google Gemini API (gemini-2.5-flash-lite) powers the Memory Enhancer. The prompt is language-aware — it detects the user's language preference and instructs the model to respond entirely in that language.

Auth: Clerk handles sign-in/sign-up and session management.

Payments: Stripe for subscription billing (Free / Personal / Family plans).

File storage: UploadThing (backed by S3) for capsule media uploads.

Challenges we ran into

Aurora DSQL schema migrations: Aurora DSQL does not support NOT NULL DEFAULT constraints on ALTER TABLE statements — only nullable columns can be added to existing tables. This broke our standard Prisma migration flow. We worked around it by writing a custom migrate.mjs script that connects via IAM token authentication and executes DDL statements sequentially, handling the Aurora DSQL-specific constraints manually.

Language switching without page reload: The dashboard layout is a server component that reads the user's language from the database. When a user changes language, we needed both client components (using React context) and server-rendered text (headings, page titles) to update immediately. The solution was a two-step approach: setLang() updates the React context optimistically for instant client-side feedback, then router.refresh() triggers a server re-render with the newly saved language — all without a hard page reload.

Clerk development banner: The Clerk pk_test_ key displays a "[Development]" banner that can't be removed without a Clerk Production instance. We accepted this as a known limitation for the hackathon submission.

Accomplishments that we're proud of

  • Instant multilingual switching — language changes propagate to both client components and server-rendered text in under a second, with no page reload
  • AI that writes in your language — the Memory Enhancer generates suggestions in whichever of the 4 languages the user has selected, not just English
  • Collaborative capsules — the contribute link feature lets multiple people add to a single capsule before it seals, a genuinely different use case from solo time capsules
  • PWA on both platforms — Add to Home Screen works on Android (native install prompt) and iOS (guided Share → Add to Home Screen flow), with platform detection
  • Production-ready architecture — Aurora DSQL + Vercel Cron + Stripe + Clerk form a stack that could support real users at scale without infrastructure changes

What we learned

Aurora DSQL is opinionated in the right ways. Its constraints (no NOT NULL DEFAULT on ALTER, sequential DDL) pushed us toward cleaner migration practices. The IAM-based authentication and the ACID guarantees at distributed scale are genuinely impressive — and the right foundation for an app where data integrity matters years into the future.

v0 accelerates the hardest part. Starting a new project, the blank canvas is the biggest obstacle. v0 let us generate a coherent, dark-themed UI scaffold quickly, which meant we spent our time on product decisions rather than pixel-pushing from scratch.

Optimistic UI + server refresh is a powerful pattern. Next.js App Router's router.refresh() combined with React context state gives you the best of both worlds: instant feedback for the user, and eventual consistency with server-rendered content — without a full page reload.

Built With

Share this project:

Updates

posted an update —

We renamed: Vaultly is now Laterloom

When we started this project, we called it Vaultly — because the core idea was locking something away until the right moment.

But the more we built it, the more "Vault" felt wrong. A vault is cold. Corporate. You lock things in a vault because you don't trust what's outside. That's not what this app is about.

A loom weaves things together. Threads from the past, carried forward into the future. And later — well, that's the whole point. Something you made today, arriving exactly when it should.

Laterloom captures what the app actually does: it weaves your memories across time and delivers them later, when they mean the most.

What's shipped so far:

  • Time capsule creation with countdown timer and locked/unlocked states
  • AI Memory Enhancer powered by Google Gemini — asks m you write deeper messages
  • 4 languages — English, Japanese, Chinese, Vietnamese — switchable instantly without page reload, AI output matches your language
  • Collaborative capsules — share a contribute link so ssages before the capsule seals
  • PWA — installable on iOS and Android home screens
  • Freemium model — Free / Personal ($5/mo) / Family ($
  • Built on Amazon Aurora DSQL + Vercel, scaffolded with v0 by Vercel

Seal today. Open tomorrow.

Log in or sign up for Devpost to join the conversation.