Owami

An AI-powered, API-first social cookbook that turns users' recipes and food knowledge into intelligent, personalized cooking experiences.

Comment

Owami — Your Recipes. Your Cookbook. Your Community.

Inspiration

Owami was inspired by a simple idea: everyone has food knowledge worth preserving and sharing.

Many recipes live in handwritten notebooks, WhatsApp messages, social media posts, or are passed from one person to another without ever being properly documented. Existing recipe platforms often focus on providing recipes to users, but we wanted to create something more personal — a digital cookbook where the users themselves create the content.

The vision behind Owami is to give people a place where they can create their own recipes, document ingredients and cooking instructions, add photos of their ingredients and finished meals, save recipes, and share their food creations with a community.

For this hackathon, we wanted to take that idea further by asking:

What if your cookbook could actually understand what you have and help you decide what to cook?

That led us to combine Owami's community-driven recipe platform with AI, cloud services, and APIs.

What We Built

Owami is an AI-powered social cookbook that allows users to:

  • Create and manage their own recipes
  • Add ingredients, quantities, instructions, preparation times, and servings
  • Upload images of ingredients and finished meals
  • Save recipes to their personal cookbook
  • Discover recipes created by other users
  • Share recipes with the Owami community
  • Search and explore recipes
  • Use AI to generate and personalize recipe ideas
  • Get suggestions based on available ingredients

The core experience remains community-driven: users create the recipes, while AI helps them make better use of their cookbook.

How We Built It

We designed Owami as an API-first, cloud-connected application rather than simply building a frontend with an AI chatbot attached.

The application is structured around separate services for users, recipes, ingredients, discovery, images, and AI functionality.

A simplified flow looks like this:

                OWAMI
                  |
             API Layer
                  |
       +----------+----------+
       |          |          |
    Recipes      AI       Users/Auth
       |          |          |
       +----------+----------+
                  |
          Cloud Database
                  |
           Image Storage

The API layer allows the frontend and AI functionality to communicate with the application's data and services in a controlled and reusable way.

For example, when a user provides a list or image of available ingredients, Owami can process that information through its AI service, communicate with the recipe API, and return relevant cooking suggestions.

This approach also means that Owami's functionality can be consumed by more than one client in the future, including a mobile application, web application, or other third-party integrations.

AI Experience

One of the key experiences we explored is "What can I cook?"

A user can provide ingredients such as:

Chicken, potatoes, tomatoes and onions.

Owami can use AI to interpret the ingredients and recommend relevant recipes from the available recipe collection.

We also explored extending this experience to images, allowing users to photograph ingredients and use AI-assisted recognition to turn those visual inputs into useful recipe suggestions.

AI can also assist with:

  • Generating recipe ideas
  • Ingredient substitutions
  • Adjusting recipes for different serving sizes
  • Personalizing recommendations
  • Helping users make use of ingredients they already have

The goal was not to build another generic AI chatbot. AI is integrated into the actual cookbook experience.

What We Learned

Building Owami taught us that adding AI to an application is not enough by itself. The AI needs to solve a real problem within the product.

We learned how important it is to design the API, data model, AI workflow, and user experience together.

We also learned that user-generated content introduces additional challenges. Recipes are structured information, while images, descriptions, measurements, and cooking instructions can vary significantly between users. Designing a flexible data model while maintaining a consistent user experience became an important part of the development process.

The project also strengthened our understanding of designing applications around APIs and cloud services instead of treating them as optional integrations.

Challenges

One of our biggest challenges was deciding how much functionality to build without losing focus.

Owami could potentially include social features, subscriptions, advanced AI, meal planning, nutrition information, shopping lists, image recognition, and many other features. We had to prioritize the features that best demonstrated the core value of the application.

Another challenge was integrating AI in a meaningful way. We wanted AI to interact with real Owami data and user actions rather than simply providing a standalone conversation interface.

We also had to think about image uploads, user-generated content, authentication, API communication, data storage, and scalability while keeping the experience simple enough for users.

What Comes Next

Owami is designed to grow beyond a simple recipe application.

Future versions could include intelligent meal planning, personalized cooking recommendations, grocery-list generation, dietary preferences, nutritional analysis, richer community interactions, creator profiles, premium cookbooks, and more advanced image-based ingredient recognition.

Our long-term vision is simple:

Owami should become a cookbook that belongs to everyone who uses it — preserving individual recipes while turning the collective knowledge of its community into something intelligent, useful, and shareable.

Built With

Share this project:

Updates

Submission history