I Built an AI-Powered Family Recipe Archive That Turns Grandpa's Voice Into Heirlooms

dikshant agarwal — Sun, 04 Oct 2026 15:11:13 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend.

What I Built

I built Grandpa's Table, a voice-to-heirloom recipe archive designed for families who have recipes that exist mostly in someone's memory.

The idea came from a simple problem:

What happens to a family recipe when the person who knows how to make it is no longer around to explain it?

A recipe isn't always a list of ingredients.

Sometimes it's:

"Add a little more until it looks right."

"Cook it until the smell changes."

"Your grandmother always added this at the end."

Those details are difficult to capture in a traditional recipe app.

So I built Grandpa's Table around voice instead of forms.

A family member can simply speak a recipe, including the ingredients, preparation steps, cooking advice, and the stories surrounding it.

The app then uses AI to transform that unstructured voice input into a structured heirloom recipe.

The workflow

Speak → Understand → Preserve → Cook → Pass it on

The resulting recipe can contain:

Ingredients
Preparation steps
Cooking instructions
Family stories
Recipe provenance
Cooking tips
Personal notes

And the recipe doesn't disappear into a cloud-only database.

The archive is local-first, with recipes stored in the browser by default and portable backups available for safekeeping.

Why I Built It

I didn't want to build another AI chatbot.

I wanted to build something where AI solves a very specific human problem.

Family knowledge is often passed from one generation to another informally.

Someone watches their grandmother cook.

Someone listens to their grandfather explain a recipe.

Someone remembers a particular ingredient or technique.

Then life happens.

People move.

Families change.

Memories fade.

And eventually, a recipe that existed for decades can disappear because nobody wrote it down.

Grandpa's Table is my attempt to turn those temporary conversations into something that can survive generations.

Demo

Project repository:

https://github.com/dikshant363/Grandpa-s-Table

The repository contains the complete application, setup instructions, architecture, and source code.

The application also includes sample heirloom recipes so the experience can be explored without recording a new recipe first.

Features

🎙️ Voice Memo Studio

Instead of forcing someone to fill out a complicated recipe form, Grandpa's Table starts with natural speech.

You can describe:

What you're cooking
Ingredients
Preparation
Cooking instructions
Family stories
Personal tips

The goal is to make capturing a recipe feel like talking to a family member.

🧠 AI Recipe Organization

The AI takes an unstructured recipe recording and turns it into a structured recipe record.

This is important because family recipes are rarely delivered in a clean format.

The AI helps organize the information without requiring the person sharing it to understand how recipes should be structured.

📖 Heirloom Recipe Library

Recipes can be browsed through a book-inspired archive.

Recipes can be:

Saved
Favorited
Opened in an archival view
Reviewed before preservation

👨‍🍳 Kitchen Mode

A recipe shouldn't only be something you read once.

Kitchen Mode turns the saved recipe into an interactive cooking experience.

It provides step-by-step instructions with timers and audio cues so the archive can actually be used while cooking.

🔊 Storyteller Mode

Recipes aren't only data.

The application can read recipe transcripts using browser speech synthesis, giving the archive a more personal storytelling experience.

📦 Portable Exports

A family archive shouldn't be locked inside one application.

Grandpa's Table supports:

JSON
PDF
Standalone HTML

It can also export and restore the complete recipe vault.

That means the data can remain useful even if the application changes in the future.

How I Built It

The application is built with a modern TypeScript-first web stack:

Next.js 15
React 19
TypeScript
Tailwind CSS
Google GenAI SDK
Web Speech API
Web Audio API
jsPDF
Lucide React
Motion

The repository uses the Next.js App Router and separates the application into the main UI, reusable components, hooks, domain types, audio functionality, and export utilities.

The core architecture looks roughly like this:

Voice Input
    ↓
AI Processing
    ↓
Structured Recipe
    ↓
Local Recipe Archive
    ↓
┌───────────────┬──────────────┬───────────────┐
│               │              │               │
Cooking Mode    Storyteller    PDF / HTML      JSON Vault
│               │              │               │
Cooking         Listening      Keepsake        Backup

AI processing is handled through the configured Gemini integration.

The important architectural decision is that AI isn't the database.

AI helps transform the messy human input into structured information.

The resulting recipe belongs to the user.

Local-First by Design

One of the decisions I cared about most was keeping the archive local-first.

Saved recipes are stored in browser localStorage by default.

That gives the project several useful properties:

No mandatory account
No mandatory cloud database
Simple deployment
Personal recipes remain on the device by default
Data can be exported
The archive remains portable

AI processing is different: when the AI feature is used, the relevant request is sent through the configured Gemini integration.

So the privacy model is intentionally simple:

Local storage for the archive. AI only when the user invokes AI processing. Portable exports for long-term preservation.

Why Does Open Innovation Matter?

This project would have been much harder to experiment with if the intelligence layer were treated as a completely closed black box.

Open innovation matters here because the architecture can evolve.

Today, Grandpa's Table uses the Gemini API for recipe processing.

But the application is structured around a clear separation between:

human input → AI transformation → structured recipe → user-owned archive

That separation means the intelligence layer can potentially be replaced or extended in the future.

An open ecosystem also makes it easier to experiment with different models, local inference, speech technologies, and AI workflows without rebuilding the entire application around one provider.

More importantly, the project itself demonstrates something I think is important about AI:

AI doesn't have to replace human knowledge. It can help preserve it.

The valuable information in this application comes from people.

The AI is there to help capture, organize, and make that knowledge usable.

Privacy and Data Portability

Family recordings and recipes can contain personal information, so I didn't want the project to assume that everything belongs in a permanent cloud database.

The archive supports:

Local storage → JSON backup → PDF keepsake → standalone HTML

This makes the data portable rather than locking the family archive into one service.

For important archives, users should still maintain independent backups.

My Agent Session

I used AI-assisted development while building the project.

The challenge encourages participants to show the process behind their project, including coding-agent sessions where available.

Agent session:

Add your DevRelay / Claude Code / Codex / Gemini CLI session here before publishing.

For example:

{% agent_session YOUR_SESSION_ID %}

I would strongly recommend adding this if you have a valid session. It gives judges evidence of how the project was actually developed rather than only showing the final result.

Prize Categories

For the submission, I would only claim categories corresponding to technologies that are genuinely used in this project.

Currently, the repository clearly documents the Google GenAI/Gemini integration and the TypeScript/Next.js application stack.

I would not add partner categories such as Render, Backboard, ElevenLabs, Mastra, MongoDB Atlas, Temporal, or others unless those technologies are actually part of the submitted project.

The challenge explicitly states that partner categories require genuine use of the partner's technology.

What's Next?

Grandpa's Table is intentionally small, but the idea can go much further.

Possible future directions include:

Multilingual recipe recording
Better preservation of regional cooking terminology
Speaker-aware family archives
Recipe lineage across generations
Ingredient and measurement normalization
Family member attribution
Search across voice transcripts
Offline AI processing
More sophisticated voice preservation
Printed family cookbooks generated directly from the archive
Shared family vaults with explicit privacy controls

But the core idea stays the same:

Don't just save the recipe. Save the person, story, and knowledge behind it.

Try It

GitHub:

https://github.com/dikshant363/Grandpa-s-Table

If you have a family recipe that exists only because someone remembers how to make it, try recording it before that knowledge disappears.

Built for the recipes, voices, and stories that make family meals worth remembering.

DEV Community: dikshant agarwal