Plated

About the Project

Inspiration

Plated was inspired by a simple but frustrating behavior we see everywhere:
people constantly save recipes, but rarely cook them.

Social media has made food discovery effortless. TikTok, YouTube, and blogs provide endless inspiration. But inspiration does not equal execution. Recipes end up scattered across bookmarks, screenshots, and notes apps.

The idea that sparked Plated was simple:

What if the gap between discovering a recipe and actually cooking it disappeared?

We were inspired by the insight that the real problem is not finding recipes.
It is converting inspiration into action.

Plated exists to remove that friction.

What We Built

Plated is a mobile app that turns recipe links into structured, actionable cooking plans.

The core flow is intentionally simple:

Paste a recipe link
Extract ingredients and steps
Save it
Automatically generate a grocery list

Ingredients from multiple recipes are merged and categorized automatically, reducing manual work.

Instead of collecting recipes, users actually cook them.

Our guiding principle was clarity over complexity. We focused on making one core workflow feel seamless and intuitive.

How We Built It

Plated was built as a local first mobile application using Expo and React Native.

The architecture is centered around three main systems:

Recipe Parsing Layer
Unstructured content from links is converted into structured data such as:
- Title
- Ingredients
- Steps
- Servings
Data Model & Local Storage
Recipes and grocery items are stored locally for instant performance and offline usability.
This makes the app responsive and reliable.
Grocery Aggregation Engine
We designed a merging system that combines ingredients across recipes.
Conceptually, the grocery list can be thought of as:

$$ L = \bigcup_{i=1}^{n} R_i $$

where each ( R_i ) represents the ingredient set of a saved recipe.

When quantities are compatible, we attempt aggregation:

$$ q_{total} = \sum_{k=1}^{m} q_k $$

where compatible ingredient quantities are summed together.

We also implemented subscription gating using RevenueCat to support a scalable Pro model while keeping the core experience accessible.

Challenges We Faced

1. Parsing Real World Content

Recipe content is highly inconsistent. Ingredient formats vary widely, units differ, and websites structure content differently. Normalizing data while preserving usability required thoughtful fallback strategies.

2. Design Restraint

It is tempting in a hackathon to add more features. Instead, we deliberately focused on one strong flow and refined it. Achieving simplicity without feeling empty required multiple iterations.

3. Aggregation Edge Cases

Merging ingredients sounds simple but quickly becomes complex.
For example:

"2 cups flour"
"200g flour"

These cannot be merged without unit normalization.
We designed smart merge attempts with graceful fallback behavior to avoid breaking usability.

4. Balancing Speed and Quality

Hackathons reward speed, but we wanted Plated to feel like a real product. We invested time into typography, spacing, interaction feedback, and consistency.

What We Learned

We learned that reducing friction creates more value than adding features.

A small, well designed system can have a disproportionate impact if it solves a real pain point.

We also learned how complex unstructured data becomes when translated into real user workflows. Even something as simple as a grocery list hides meaningful edge cases.

Most importantly, we learned that clarity in design amplifies trust.
When a product feels intentional, users assume it works.