CommonTable — One table. Everyone included.

Masna Manideep — Mon, 05 Oct 2026 07:28:12 +0000

🍽️ What if your meal planner actually knew your friends?

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

What I Built

Meet CommonTable — a collaborative AI meal planner designed for people who actually eat together.

Imagine this:

Three friends live together.

One is vegetarian.
One has a peanut allergy.
One is lactose intolerant.

Someone has to cook tonight.

They suggest a recipe in the app. Everyone gets notified, reviews it, and can suggest changes.

The system checks the recipe against the household's dietary constraints, identifies conflicts, and helps find safer alternatives.

Instead of:

“What should we eat?”

the app helps answer:

“What can all of us actually eat?”

The workflow

👨‍🍳 Cook proposes a meal

↓

📢 Friends receive the proposal

↓

💬 Friends suggest changes

↓

🤖 AI adapts the recipe

↓

🛡️ Safety engine checks the updated ingredients

↓

✅ Everyone approves

↓

🛒 Grocery list is generated

The goal isn't to create another AI recipe generator.

It's to make group meal planning less chaotic, more collaborative, and safer.

How I Built It

The project is a responsive web application built around open-source AI and a deterministic safety layer.

Stack

Frontend

React
TypeScript
Vite
Tailwind CSS

Backend

FastAPI
Python
MongoDB

Open-source/open-weight LLM
Structured recipe generation
Ingredient normalization
Recipe modification
Feedback summarization

One important architectural decision

I deliberately didn't let the LLM decide whether a meal is safe.

The flow is:

User / Cook
     ↓
AI generates recipe
     ↓
Structured ingredients
     ↓
Ingredient normalization
     ↓
Safety & constraint engine
     ↓
Household profiles
     ↓
SAFE / UNSAFE / NEEDS REVIEW

The AI can suggest a substitution.

The safety engine decides whether the resulting recipe conflicts with the household's known constraints.

That separation is important because an LLM sounding confident doesn't make a food-safety decision reliable.

Why Does Open Innovation Matter?

Open innovation made it possible to build this as more than a thin wrapper around a closed AI API.

Using open-source and open-weight technologies gives us the ability to:

Experiment with different models.
Run models locally when needed.
Control how recipe information is processed.
Customize structured outputs.
Build our own safety and reasoning layer around the model.
Replace the AI provider without rebuilding the entire product.

More importantly, the project isn't dependent on the model being the entire product.

The model is one component.

The household context, collaboration workflow, safety engine, and product logic belong to us.

That's the part that turns an AI demo into an actual product.

Why I Built This

Most meal-planning apps think about one person.

Real dinners usually involve more than one.

When you're cooking with friends or roommates, the problem isn't just finding a recipe.

It's remembering:

Who can eat this?

Who can't?

What can we change?

Does everyone agree?

What do we actually need to buy?

I wanted to turn that messy conversation into one simple workflow.

Propose. Discuss. Adapt. Check. Approve. Eat.

And hopefully, fewer:

“Wait... does this contain peanuts?” 😅

Prize Categories

[Add applicable partner categories here.]

Built for the people you actually share dinner with. 🍲

If you live with roommates, cook with friends, or regularly have to plan around different diets and allergies, this is the kind of problem I'd love to make easier.

Feedback is welcome — especially from people who have experienced the “What are we eating tonight?” group-chat debate. 😄

GitHub: [Add repository]

Demo: [Add deployed URL]

DEV Community: Masna Manideep