DEV Community: Orlando Ezequiel Salazar Cruz

Listify AI — Create Better Product Listings with Open-Weight AI

Orlando Ezequiel Salazar Cruz — Mon, 19 Oct 2026 03:31:55 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Meet Listify AI, an AI-powered web application designed to help small businesses, entrepreneurs, and independent sellers create professional product listings in seconds.

When selling products online, having a great product is only part of the challenge. Writing engaging descriptions, choosing the right words, creating hashtags, and adapting content for different platforms can take time.

For small business owners who manage everything themselves, that time matters.

Listify AI solves this problem by transforming simple product details into ready-to-use marketing content using open-weight artificial intelligence.

Users provide information about their products, choose their preferred writing style, and let AI generate the content.

What can Listify AI do?

Generate product titles that highlight important features.

Write compelling descriptions based on the information provided.

Create relevant hashtags for social media.

Generate calls to action to encourage customer engagement.

Customize writing tones, including professional, friendly, persuasive, creative, and minimalist.

Adapt content for different platforms, including Instagram, Facebook Marketplace, and online stores.

Support English and Spanish for generated content.

Copy generated content with a single click.

The application features a clean, responsive interface designed to make AI-powered content creation accessible to everyone.

As a potential side hustle, Listify AI could evolve into an affordable content creation service for small businesses and independent online sellers.

The mission is simple:

Less time writing. More time selling.

Demo

Listify AI is deployed and available to try directly in your browser.

Live Demo: https://listify-ai-mbrq.vercel.app/

No registration is required.

How It Works

Describe your product

Enter the product name, category, price, and key features.

Customize your content

Select your preferred selling platform, writing tone, and output language.

Generate with AI

Click Generate Listing and let the AI transform your product details into marketing content.

Copy and share

Review the generated title, description, hashtags, and call to action. Copy the results and use them on your preferred platform.

Example: Wireless Bluetooth Headphones

For testing, I used a sample product with the following information:

Product: Wireless Bluetooth Headphones

Category: Electronics

Features: Bluetooth 5.3, up to 30 hours of battery life, USB-C charging, built-in microphone, and comfortable cushioned ear cups.

Price: $49.99 USD

Platform: Instagram

Tone: Persuasive

Language: English

Listify AI uses this information to generate a product title, description, hashtags, and a call to action tailored to the selected settings.

This demonstrates how an open-weight language model can turn a few product specifications into content that sellers can review and publish.

Code

Listify AI was developed using a lightweight web architecture with a JavaScript frontend and a serverless backend.

GitHub Repository: https://github.com/Ezequie1Sc/listify-ai

Tech Stack

Technology

Purpose

HTML5

Application structure

CSS3

Responsive design and animations

JavaScript

Frontend functionality

Node.js

Serverless backend runtime

Google Gemma 3 12B

Open-weight AI model

OpenRouter

Model inference API

Vercel

Hosting and serverless deployment

Git & GitHub

Version control

The main application components include:

index.html — User interface and application structure.

css/styles.css — Visual design, responsive layouts, and animations.

js/app.js — User interactions, form validation, API requests, and generated content rendering.

api/generate.js — Serverless endpoint that communicates with the AI model.

The project keeps sensitive API credentials in server-side environment variables rather than exposing them in the browser.

How I Built It

I wanted Listify AI to be simple, fast, and easy to use.

Instead of introducing a large frontend framework, I built the interface with HTML, CSS, and vanilla JavaScript.

For the AI functionality, I integrated Google Gemma 3 12B, an open-weight language model accessed through the OpenRouter API.

How the AI Works

The application follows a straightforward generation process:

Product Information → JavaScript Frontend → Vercel Serverless Function → OpenRouter → Google Gemma 3 → Generated Listing

When users submit the form, the frontend collects their product information and sends it to the /api/generate endpoint.

The backend validates the request and constructs a structured prompt containing the product name, features, category, price, platform, tone, and language.

The AI model then generates a response containing four main elements:

Product title

Product description

Relevant hashtags

Call to action

The backend processes the response and returns the generated content to the frontend, where users can review and copy it.

Why AI Is Essential to the Project

The open-weight model is not an optional addition to Listify AI.

It is the core of the application.

Without the language model, the application would only collect product information. Gemma 3 transforms that information into useful, customized marketing copy.

The model is instructed to work with the information provided by the user and avoid inventing unsupported product specifications.

Technical Challenges

During development, I encountered several challenges involving AI integration and deployment.

Some models had unavailable inference endpoints, while others encountered rate limits.

I also faced a production configuration issue where the serverless backend could not detect the configured model because an environment variable had been named incorrectly.

By examining Vercel function logs, I identified the problem, corrected the configuration, and successfully restored the AI generation functionality.

These challenges helped me better understand API integration, serverless architecture, environment variables, structured responses, and production debugging.

Why Does Open Innovation Matter?

Open innovation matters to me because it makes powerful technology more accessible to students, independent developers, and small teams.

When building Listify AI, I wanted to explore how an open-weight language model could power a practical application without relying entirely on a proprietary model.

Freedom to Experiment

Using Gemma 3 gives me the flexibility to explore different inference configurations and potentially replace the underlying model with another compatible open-weight model.

This makes the architecture more adaptable as the project evolves.

More Deployment Possibilities

The current version of Listify AI uses OpenRouter for hosted inference.

However, because Gemma 3 is an open-weight model, its weights can be used through other compatible inference solutions, subject to its license and hardware requirements.

This creates opportunities to explore self-hosting and alternative deployment environments in the future.

Lower Barriers to Entry

As a student developer, being able to experiment with accessible AI models and development tools is extremely valuable.

Open-weight AI makes it easier to learn, prototype, and build applications without needing a large development budget.

Building Useful Tools

What excites me most about open innovation is its potential to help solve everyday problems.

Listify AI is a small example of how AI can support independent sellers who may not have the time or resources to create professional marketing content for every product.

I believe the future of AI should include opportunities for developers of all backgrounds to experiment, contribute, and create useful applications.

Open innovation turns powerful technology into opportunities for more people to build.

What I Learned

Building Listify AI helped me strengthen several technical skills:

Integrating open-weight language models into web applications.

Designing structured prompts for practical use cases.

Developing and deploying serverless API endpoints.

Handling AI service errors and rate limits.

Protecting API credentials through environment variables.

Building responsive interfaces with vanilla JavaScript and CSS.

Debugging production deployments through serverless logs.

Most importantly, I learned that creating a useful AI application requires more than choosing a model.

It requires thinking about the user experience, reliability, security, and how the technology solves a real problem.

What's Next?

Listify AI is an early version, and I would like to continue improving it.

Some features I plan to explore include:

Multiple AI-generated listing variations.

Additional languages and selling platforms.

Product listing history and reusable templates.

Support for product images.

More open-weight AI model options.

Improved rate limiting and API protection.

Alternative inference providers and self-hosting experiments.

These improvements could help transform Listify AI into a more complete tool for entrepreneurs and online sellers.

Final Thoughts

Listify AI started with a simple question:

What if creating a professional product listing could be as easy as describing the product itself?

This project allowed me to explore how open-weight artificial intelligence can turn that idea into a working application.

It was a valuable experience combining frontend development, serverless architecture, AI integration, and deployment.

I'm excited to continue learning and building with open technologies.

Thanks to the DEV Community and Hacktoberfest for encouraging developers to experiment, share their projects, and explore the possibilities of open AI.

Live Demo: https://listify-ai-mbrq.vercel.app/

Source Code: https://github.com/Ezequie1Sc/listify-ai

Thanks for reading!

hacktoberfest #opensource #ai #webdev

Listify AI — Turning Simple Product Details into Better Listings with Open-Weight A

Orlando Ezequiel Salazar Cruz — Mon, 19 Oct 2026 03:25:04 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Meet Listify AI, a web application that helps small businesses, entrepreneurs, and independent sellers create professional product listings using open-weight artificial intelligence.

Selling products online involves more than uploading a picture and adding a price. A good listing needs an attractive title, a clear description, relevant hashtags, and a compelling call to action.

However, creating this content repeatedly can take valuable time, especially for people managing their businesses on their own.

That's where Listify AI comes in.

Listify AI transforms basic product information into ready-to-use marketing content in seconds.

Users simply enter their product details, choose a platform and writing style, and let AI handle the creative writing.

Key Features

AI-generated titles: Create engaging titles that highlight the product.

Product descriptions: Turn simple specifications into clear, attractive descriptions.

Relevant hashtags: Generate hashtags related to the product.

Calls to action: Encourage potential customers to take the next step.

Multiple writing tones: Choose between professional, friendly, persuasive, creative, and minimalist styles.

Platform customization: Adapt listings for Facebook Marketplace, Instagram, online stores, or general use.

Multilingual generation: Generate content in English or Spanish.

Copy-to-clipboard: Easily reuse generated content on selling platforms.

Responsive interface: Use the application on desktop or mobile devices.

The idea behind Listify AI is simple: help sellers spend less time writing listings and more time growing their businesses.

As a potential side hustle, the application could evolve into an affordable content creation service for online sellers who regularly publish new products.

Demo

Listify AI is deployed on Vercel and available to try directly in your browser.

Live Demo: https://listify-ai-mbrq.vercel.app/

How It Works

Step 1 — Enter your product information

Provide the product name, category, price, and main features.

Step 2 — Customize your listing

Choose your preferred selling platform, writing tone, and language.

Step 3 — Generate with AI

Click the generation button and let the AI create a product listing based on your information.

Step 4 — Copy and publish

Review the generated title, description, hashtags, and call to action. Copy the content and use it on your preferred selling platform.

The goal was to make the experience intuitive, even for users who have never worked with AI tools before.

Code

Listify AI is built with a lightweight architecture that separates the frontend from the AI integration.

GitHub Repository: https://github.com/Ezequie1Sc/listify-ai

Project Structure

listify-ai/
├── api/
│ └── generate.js
├── css/
│ └── styles.css
├── js/
│ └── app.js
├── index.html
├── package.json
├── vercel.json
├── .env.example
├── .gitignore
└── README.md

The application uses vanilla JavaScript for user interactions and a Vercel serverless function for communicating with the AI provider.

API credentials are stored in server-side environment variables rather than exposed in the frontend.

The repository contains the application code, styling, AI integration, and deployment configuration.

How I Built It

I wanted Listify AI to be fast, accessible, and easy to maintain.

Instead of using a complex frontend framework, I chose HTML, CSS, and vanilla JavaScript.

This allowed me to focus on the user experience and the AI-powered functionality.

Technology Stack

Technology

Purpose

HTML5

Application structure

CSS3

Responsive design and animations

JavaScript

Frontend logic and API integration

Node.js

Serverless function runtime

Google Gemma 3 12B

Open-weight language model

OpenRouter

AI inference provider

Vercel

Hosting and serverless deployment

Git & GitHub

Version control and source code

The AI Model

For the AI functionality, I integrated Google Gemma 3 12B, an open-weight language model accessed through OpenRouter.

The model is responsible for transforming structured product information into useful marketing content.

Instead of returning generic text, the application builds a prompt using the user's product details, selected platform, preferred writing tone, and language.

The AI is instructed to generate a structured response containing:

Product title

Product description

Relevant hashtags

Call to action

This is the core functionality of Listify AI. Without the language model, the application would not be able to transform raw product details into complete marketing copy.

Application Architecture

The generation process follows this workflow:

When a user submits the form, JavaScript collects and validates the input before sending a request to the backend.

The serverless function processes the request, builds the AI prompt, and communicates with OpenRouter.

Once the model returns a response, the backend validates the generated content and sends it back to the frontend.

The application then displays the result in an organized interface.

Building the User Interface

I wanted the application to feel modern, minimal, and approachable.

The interface uses clean typography, balanced spacing, subtle animations, and responsive layouts.

I also focused on making the generation process easy to understand through clear input fields, loading indicators, error messages, and organized results.

Challenges I Faced

One of the most interesting parts of building Listify AI was connecting the deployed application to the AI service.

During development, I encountered several issues:

AI models without available inference endpoints.

API rate limits when testing free models.

Serverless configuration errors.

Environment variables not being detected correctly.

Handling unsuccessful requests and invalid AI responses.

One particularly useful debugging experience involved a deployment error caused by an incorrectly named environment variable.

The frontend was working, but the backend could not find the model configuration.

By reviewing the Vercel function logs, I identified the issue and corrected the environment variable.

This experience reminded me that developing an AI-powered application is not just about writing prompts. It also requires reliable backend integration, debugging, deployment, and error handling.

Why Does Open Innovation Matter?

I believe open innovation is important because it makes advanced technology more accessible to independent developers, students, and small teams.

For Listify AI, using an open-weight model was a deliberate architectural choice.

Freedom to Experiment

Open-weight models give developers opportunities to experiment with different models and inference configurations.

Rather than permanently depending on a single proprietary language model, Listify AI can be adapted to use other compatible models.

More Deployment Options

Because Gemma 3 provides openly available model weights under its license, developers can explore alternative inference environments.

Although the current version of Listify AI uses OpenRouter for hosted inference, the underlying model could potentially be deployed through a different compatible provider or a self-hosted setup.

This flexibility is valuable for projects that may grow beyond their initial prototype.

Lower Barriers to Building

As a student developer, access to AI models and affordable development tools makes a meaningful difference.

Open-weight models and free inference options create opportunities to experiment with AI applications without requiring a large initial budget.

Learning and Transparency

Working with an open-weight model encouraged me to learn more about model selection, prompt design, inference APIs, structured outputs, and deployment.

It also made me think about the importance of building applications where the AI component can be understood, evaluated, and replaced.

Open innovation matters because it gives more people the opportunity to turn their ideas into working applications.

For a project like Listify AI, that means exploring how accessible AI can help small sellers solve everyday problems.

What I Learned

Building Listify AI taught me valuable lessons about creating practical AI-powered web applications.

Some of my biggest takeaways were:

AI integration: How to connect an open-weight language model to a real application.

Prompt engineering: How to structure requests to generate consistent, useful results.

Serverless architecture: How to build and deploy backend functionality without managing a traditional server.

Security: Why API keys must remain on the server.

Error handling: How to respond to model unavailability, rate limits, and failed requests.

UI/UX design: How to make AI functionality accessible through a simple interface.

Deployment: How to debug production issues using Vercel logs and environment variables.

This project also reinforced something I enjoy about software development: taking a simple idea, experimenting with different approaches, solving unexpected problems, and gradually turning it into something functional.

What's Next?

Listify AI is still an early version, and I would like to continue improving it.

Some features I would like to explore include:

Generating multiple listing variations.

Adding more languages and selling platforms.

Supporting additional open-weight AI models.

Saving previously generated listings.

Creating reusable product listing templates.

Generating content from uploaded product images.

Adding stronger API rate limiting.

Exploring alternative inference providers and self-hosted models.

These improvements could help Listify AI become a more complete content creation tool for independent sellers.

Final Thoughts

Listify AI started with a simple idea:

What if creating a professional product listing could be as easy as describing the product itself?

Through this project, I explored how open-weight artificial intelligence can help solve a practical problem for small businesses and online sellers.

I'm excited to keep learning, improving the application, and experimenting with open AI technologies.

Thanks to the DEV Community and Hacktoberfest for creating opportunities to build, share, and learn.

Try Listify AI: https://listify-ai-mbrq.vercel.app/

Explore the source code: https://github.com/Ezequie1Sc/listify-ai

Thanks for reading!

hacktoberfest #opensource #ai #webdevThis is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

Benchmarking Free AI Models for Outdoor Adventure Generation

Orlando Ezequiel Salazar Cruz — Sat, 10 Oct 2026 06:54:33 +0000

This is a submission for the Kaggle Benchmarking Challenge

What I Benchmarked

For Ruta Viva AI, an outdoor exploration app, I wanted to evaluate how reliably free AI models can generate structured outdoor adventures.

The benchmark measures more than whether a model responds successfully. Each adventure must contain valid JSON, all required fields, exactly three missions, and consistent XP totals.

I designed 30 scenarios across 10 environments, with three prompt variations for each environment. For this initial pilot, I tested three scenarios per model, resulting in nine requests.

Models Tested

I evaluated three free models through OpenRouter:

Liquid LFM 2.5 2.6B: liquid/lfm-2.5-2.6b:free
NVIDIA Nemotron 3.5 Lightning: nvidia/nemotron-3.5-lightning:free
Apodex 1.1 Mini: apodex/apodex-1.1-mini:free

I chose these models to compare structured-output reliability and response speed using a common set of prompts.

Findings

The pilot revealed significant differences in structured-output reliability.

Model	Valid JSON	Median latency
Liquid LFM 2.5 2.6B	3/3 (100%)	13.57 s
NVIDIA Nemotron 3.5 Lightning	1/3 (33.3%)	41.37 s
Apodex 1.1 Mini	0/3 (0%)	6.36 s

Liquid was the most reliable model in this pilot. All three responses contained valid JSON, the required fields, exactly three missions, and consistent XP totals.

Nemotron produced one valid response; two were truncated at the output limit. Apodex was the fastest by median latency, but none of its responses produced valid JSON, and one returned no usable answer content.

My main takeaway is that speed alone does not determine usefulness. When an application depends on structured data, a fast response that cannot be parsed may be less valuable than a slower, correctly formatted response.

This benchmark has limitations: three requests per model are not enough to establish general performance. The safety check is a basic keyword heuristic, not proof of safety, and adventure quality still requires human evaluation.

Next, I would test more scenarios, repeat requests to measure consistency, and manually evaluate relevance, accessibility, variety, practicality, and safety.

My Benchmark

Public Kaggle notebook: https://www.kaggle.com/code/ezequielsalazar1/outdoor-adventure-ai-benchmark

GitHub repository: https://github.com/Ezequie1Sc/outdoor-adventure-ai-benchmark

The notebook documents the benchmark methodology and validation logic. The results above come from the pilot I ran locally.

kagglechallenge

🌿 Ruta Viva AI: Turning Everyday Walks into AI-Powered Adventures

Orlando Ezequiel Salazar Cruz — Fri, 09 Oct 2026 22:43:26 +0000

What if AI could help us spend less time staring at screens and more time exploring the world?

That's the idea behind Ruta Viva AI, an AI-powered outdoor adventure platform that transforms ordinary walks into interactive missions. Instead of spending more time scrolling, users can discover their surroundings, complete real-world challenges, and earn XP while exploring nature and local culture.

The goal is simple: make the screen the shortest part of the adventure.

What I Built

Ruta Viva AI turns going outside into a game.

Users choose their preferred adventure type, difficulty, and duration. The application then selects an adventure containing missions designed to encourage real-world exploration.

Adventure categories include:

🌳 Nature: Observe plants, discover patterns, identify colors, and listen to the sounds around you.

🏛️ Culture: Explore architecture, public art, and interesting details in your community.

🚶 Walking: Turn an ordinary walk into a sequence of small challenges.

🎲 Surprise: Let the adventure system choose an unexpected exploration experience.

Each adventure includes missions, descriptions, and experience points (XP). The idea is to give people a reason to step outside, pay attention to their surroundings, and turn everyday activities into memorable experiences.

The project is designed for curious people who want to explore their communities, enjoy the outdoors, and make their walks more engaging.

Demo

Try the deployed application:

Live application: https://ruta-viva-ai-hbdn.vercel.app/

Backend API: https://ruta-viva-ai-backend.onrender.com/

Interactive API documentation: https://ruta-viva-ai-backend.onrender.com/docs

The frontend is deployed on Vercel, and the FastAPI backend is deployed on Render.

Adventure Results

After each adventure, Ruta Viva AI displays the distance traveled, time spent exploring, and XP earned, giving users a clear overview of their progress and achievements.

Badges and Rewards

Based on their adventure achievements, users can earn badges to celebrate their progress and build their personal collection. Each badge encourages them to keep exploring, complete new missions, and reach new milestones.

Code

GitHub repository: https://github.com/Ezequie1Sc/ruta-viva-ai

The project is organized into a frontend and a backend:

Frontend: Angular and TypeScript.

Backend: Python and FastAPI.

Adventure catalog: A structured JSON file containing predefined adventures and missions.

AI integration: OpenRouter with a configurable model.

Deployment: Vercel and Render.

The code is structured so that the adventure catalog, selection logic, and AI provider integration can evolve independently.

How I Built It

I built Ruta Viva AI using Angular for the frontend and FastAPI for the backend.

Initially, the AI was responsible for generating an entire adventure, including its title, description, missions, and XP rewards. However, waiting several minutes for a generation was not a good experience for an application designed to encourage people to go outside.

I rethought the architecture and introduced a hybrid approach.

A structured adventure catalog

Instead of generating every mission from scratch, the application maintains a JSON catalog of predefined adventures.

Each entry includes an identifier, adventure type, difficulty, title, description, missions, and XP rewards.

This gives the application a consistent source of content and makes it easier to validate adventure data.

AI as the decision-making layer

The AI receives the user's preferences and a filtered list of candidate adventures. Its job is to select the most appropriate option instead of writing every mission from scratch.

Python filters the catalog by adventure type and difficulty before sending relevant candidates to the model. This reduces unnecessary context and the amount of generation required.

A Python fallback

An external AI provider can be slow, unavailable, or rate-limited. To make the experience more resilient, the backend can select an adventure locally when the AI call fails or times out.

This means the application can still return a valid adventure even when the external model cannot provide a selection.

Open-source AI and Ollama

One of my goals is to keep the AI layer flexible rather than tying the project to a single proprietary model or provider.

The current deployed implementation uses OpenRouter for hosted inference and supports a configurable model identifier. This makes it easier to experiment with different compatible models.

I am also interested in Ollama, which provides a practical way to run supported open-weight models locally. A local Ollama integration is a natural next step for Ruta Viva AI, allowing the project to explore local inference without requiring every AI request to go through a hosted provider.

Local inference is not currently part of the deployed version, but the separation between the catalog, selection logic, and AI service provides a foundation for adding it.

Why Does Open Innovation Matter?

Open innovation matters because AI-powered applications should be adaptable, inspectable, and open to experimentation.

For Ruta Viva AI, separating the AI provider from the adventure system makes it easier to change models, compare their behavior, and explore alternative deployment strategies.

Using a structured catalog also means that the application does not depend entirely on a model to create every piece of content. The missions can be reviewed, improved, and expanded independently of the AI provider.

Exploring Ollama and open-weight models could also make local inference possible in a future version. That would provide more control over where inference runs and could reduce dependence on an external service, although hardware requirements and model licenses would still matter.

There is an important distinction in the current implementation: the application uses hosted inference through OpenRouter, so it requires an internet connection for AI selection. The local Python fallback can still select from the catalog if the provider fails, but that does not mean the entire application currently runs offline.

For me, open innovation is about preserving the freedom to experiment and improve the system rather than building the entire experience around a single AI provider.

My Agent Session

I used AI-assisted development to explore the architecture, improve the generation workflow, and implement the JSON catalog and fallback selection.

Prize Categories

This project is submitted to the Hacktoberfest Open-Source AI Challenge — Week 1: Touch Grass.

What's Next?

There is still plenty I want to improve:

Integrate an optional local inference provider using Ollama.

Improve response times and measure AI selection latency.

Expand the adventure catalog with more varied missions.

Improve duration-aware selection so adventures better match the time users have available.

Develop GPS-based progress tracking and outdoor discovery features.

Continue improving the mobile experience.

Final Thoughts

Building Ruta Viva AI reminded me that AI does not always need to create more screen time. It can also help people step away from their devices and engage with the physical world.

Sometimes, the best technology is the kind that gives you a reason to put your phone away.

Build with AI. Explore the real world. Touch grass. 🌿

Thanks for checking out Ruta Viva AI!

Collectify: AI-Powered Inventory Management for Smarter Business Decisions

Orlando Ezequiel Salazar Cruz — Mon, 05 Oct 2026 05:01:35 +0000

What if AI wasn't a chatbot added to a business application, but part of the business itself?

For Hacktoberfest 2026, I decided to build something around a problem that is actually happening in my community.

I built Collectify, an AI-first inventory and business management platform designed for a real local store that sells anime and pop-culture collectibles such as Funko, Pokémon products, plushies, pins, posters, and other merchandise.

This is not a hypothetical business scenario.
The project is being developed around the needs of a real local store with multiple partners, where keeping track of products, ownership, sales, inventory, earnings, and purchasing decisions can become difficult when information is handled manually or spread across different places.
And that is where the idea for Collectify started.
The Real Problem
A traditional inventory system can tell you:
"You have 5 units of this product."

But a real business needs to ask much more:

Who owns those products?
Which partner's products are selling?
Which products are performing better?
What should be restocked?
What products are becoming slow-moving?
How much is each partner generating?
Where could we find suppliers?
What should we consider purchasing next?
What does the business data actually tell us? For a store with multiple partners, inventory is not just about counting products. It is also about understanding the business behind the inventory. That is the problem Collectify is designed to address. Built for a Real Business Collectify is being developed around a real local store, not an imaginary customer created specifically for the hackathon. The store has multiple partners who contribute and sell products through the same physical location. That creates a very practical challenge: How do you maintain control over everyone's products and sales while still having a unified view of the business? Collectify addresses this by connecting: Products → Partners → Sales → Earnings → Inventory → AI The objective is to give the people running the store a centralized place where they can understand what is happening and make better decisions.

The Idea Behind Collectify
I wanted to avoid a very common pattern in AI applications:
Inventory System
+
Generic Chatbot
=
"AI-powered" application

That was not the direction I wanted to take.
Instead, Collectify follows this model:
Business Data
↓
AI
↓
Understanding
↓
Recommendations
↓
Business Action

The AI is not there simply to answer questions.
It is designed to interact with the information generated by the business and turn that information into something useful.
Why AI Is Actually Useful Here
Collectify uses AI in workflows that have a direct relationship with the business.
For example:
Inventory Data
↓
AI Analysis
↓
Restocking Insights

Sales Data
↓
AI Analysis
↓
Product Performance

Partner Data
↓
AI Analysis
↓
Individual Business Insights

Product Search
↓
AI Supplier Discovery
↓
Potential Suppliers
↓
Purchasing Decision

The important part is that the AI is connected to the application's actual domain.
It is not simply sitting beside the application as a chat window.
AI Business Analysis
Collectify includes an AI analysis workflow where users can ask questions about their business.
For example:
"Which products are performing better and which ones should I consider restocking?"

The goal is to transform operational information into business insight.
Instead of manually going through multiple records, the user can interact with the business data through the AI layer.
The long-term idea is to make Collectify capable of continuously helping the business understand:

Product performance
Sales behavior
Inventory conditions
Partner performance
Potential restocking needs
Business opportunities

AI-Powered Supplier Discovery
One of the most important AI workflows in Collectify is supplier discovery.
A user can search for something like:
"Funko Pokémon"

Collectify sends the request through the backend AI workflow and returns structured supplier information.
Instead of returning only a paragraph of text, the system can produce application-ready information such as:

Supplier name
Description
Category
Location
Website
Relevance
Rating when available
Verification information when available
Supplier tags The frontend then consumes those results and renders them as supplier cards. This distinction is important. The AI is not only generating language. It is generating structured information that the application can use. User ↓ Supplier Search ↓ FastAPI ↓ AI / Supplier Discovery ↓ Structured Results ↓ Angular ↓ Supplier Cards

AI Is a Business Tool, Not a Decoration
This is probably the most important design decision behind Collectify.
I did not want to be able to say:
"My inventory application has AI."

I wanted to be able to say:
"The AI changes what the application can do."

Without the AI layer, Collectify can store business information.
With the AI layer, the system can begin to interpret that information and help transform it into decisions.
That creates a much more interesting relationship:
Store
↓
Data
↓
Understanding
↓
Decision
↓
Action

This is the direction I want to continue developing.
Multi-Partner Management
Another important part of Collectify is the multi-partner model.
The store is shared by multiple partners, which means the system needs to understand that not every product belongs to the same person.
Collectify allows the business to organize information around individual partners and their products.
This helps provide visibility into:

Product ownership
Individual inventory
Sales associated with products
Partner information
Earnings
Business performance Instead of having one large inventory with no context, Collectify creates a more structured representation of the business.

Inventory Management
Collectify provides the operational foundation required by the AI layer.
Products can contain information such as:

Name
Description
Category
SKU
Cost
Sale price
Stock
Status
Ownership The inventory is not intended to be the final product. It is the data foundation that allows the rest of the platform to work.

Sales and Earnings
Sales are connected to products and business information so that the platform can later analyze what is happening.
The earnings section provides another layer of visibility into the operation.

These sections are important because they provide the data that future AI workflows can use for deeper business analysis.
Open AI and Local Development
One of the requirements of this Hacktoberfest challenge is to build something with open-source AI at its core.
Collectify was designed around an AI layer that can work with open/open-weight models and different providers, rather than making the entire application permanently dependent on a single proprietary model.
The application was also developed and tested locally, including both the Angular frontend and the FastAPI backend.
This is important to me because I want the AI layer to remain replaceable.
Collectify
↓
AI Service
↓
Model / Provider

The application should be able to evolve as models evolve.
That means being able to:

Experiment with different models.
Replace providers.
Test different AI capabilities.
Adapt the AI layer without redesigning the entire application.
Run the core application locally. An AI-first application should not necessarily mean being locked into one model forever. Evidence of the AI Workflow The screenshots below document the actual development and functionality of the AI features.

Technology Stack
Frontend

Angular
TypeScript
SCSS
Angular HttpClient
Responsive UI Backend
Python
FastAPI
Pydantic
Uvicorn
REST API Database
Supabase
PostgreSQL AI
OpenRouter
Open/open-weight AI models
AI-powered business analysis
Structured AI supplier discovery Deployment
Vercel
Render
Supabase Architecture ┌─────────────────────────┐ │ Collectify │ │ Angular Frontend │ └────────────┬────────────┘ │ HTTP/REST │ ▼ ┌─────────────────────────┐ │ FastAPI Backend │ │ │ │ Products │ │ Sales │ │ Partners │ │ Earnings │ │ AI Analysis │ │ Supplier Discovery │ └────────────┬────────────┘ │ ┌──────────┴──────────┐ │ │ ▼ ▼ ┌──────────────────┐ ┌──────────────────┐ │ Supabase │ │ OpenRouter │ │ PostgreSQL │ │ AI Models │ └──────────────────┘ └──────────────────┘

Running Locally
Clone the repository:
git clone https://github.com/Ezequie1Sc/collectify.git

Install the frontend dependencies:
cd frontend/collectify
pnpm install

Run the frontend:
pnpm start

The Angular application will be available at:
http://localhost:4200

For the backend:
uvicorn app.main:app --reload

The API will run at:
http://127.0.0.1:8000

Health check:
http://127.0.0.1:8000/health

The project was developed and tested locally before deployment.
Live Project
Frontend
https://collectify-7xcu.vercel.app
Backend API
https://collectify-api-udxk.onrender.com
API Documentation
https://collectify-api-udxk.onrender.com/docs
GitHub Repository
https://github.com/Ezequie1Sc/collectify
Why This Project Matters
Small businesses generate valuable information every day.
But that information is often distributed across:

Spreadsheets
Messages
Notebooks
Manual records
Different applications
Conversations between partners The problem is not necessarily the lack of data. The problem is the lack of understanding. Collectify attempts to create a bridge between operational data and business decisions. Inventory ↓ Sales ↓ Business Data ↓ AI ↓ Insights ↓ Recommendations ↓ Action

That is the direction I believe AI can bring real value to small businesses.
What Makes Collectify Different?
Collectify is not trying to compete with large enterprise ERP systems.
The goal is different.
It is about taking a real small-business problem and asking:
What could happen if the business's own data became something the application could understand?

The project combines:

Inventory management

Multi-partner management

Sales and earnings

AI analysis

AI-powered supplier discovery

An AI-first business platform
And the most important part is that this architecture was shaped by an actual business problem.
What's Next?
Collectify is still evolving.
Some of the features I want to explore next include:

Sales forecasting
Automatic restock recommendations
Partner-specific analytics
Supplier comparison
Purchase recommendations
Profitability analysis
Automated business insights
Role-based access control
Advanced dashboards
More open-weight AI models
More autonomous AI workflows The long-term goal is to move from: Inventory Management

towards:
AI-Powered Business Intelligence
for Small Retail Businesses

Final Thoughts
This project changed the way I think about AI applications.
AI does not have to be a chat window placed next to an existing application.
It can become part of the application's actual workflow.
With Collectify, the goal is:
Organize Information
↓
Understand the Business
↓
Discover Opportunities
↓
Make Better Decisions

And most importantly, this is not a hypothetical problem.
Collectify was built around a real local business, with real operational needs and a real multi-partner inventory problem.
That made the project much more meaningful to build.
I did not start with:
"What AI feature can I add to my application?"

I started with:
"What problem does this business actually have, and where can AI genuinely help?"

That question shaped the entire project.
AI should not be decoration. It should solve a real problem.

Built for Hacktoberfest 2026
Hacktoberfest Weekend Challenge — Build for a Friend
Collectify — AI-powered business management for real-world retail.
GitHub:
https://github.com/Ezequie1Sc/collectify
Live Demo:
https://collectify-7xcu.vercel.app
API Documentation:
https://collectify-api-udxk.onrender.com/docs

Collectify: Building an AI-First Business Platform for a Real Local Store

Orlando Ezequiel Salazar Cruz — Mon, 05 Oct 2026 04:32:05 +0000

What if AI wasn't a chatbot added to a business application, but part of the business itself?

For Hacktoberfest 2026, I decided to build something around a problem that is actually happening in my community.
I built Collectify, an AI-first inventory and business management platform designed for a real local store that sells anime and pop-culture collectibles such as Funko, Pokémon products, plushies, pins, posters, and other merchandise.

But a real business needs to ask much more:

Who owns those products?
Which partner's products are selling?
Which products are performing better?
What should be restocked?
What products are becoming slow-moving?
How much is each partner generating?
Where could we find suppliers?
What should we consider purchasing next?
What does the business data actually tell us?

For a store with multiple partners, inventory is not just about counting products.
It is also about understanding the business behind the inventory.
That is the problem Collectify is designed to address.
Built for a Real Business
Collectify is being developed around a real local store, not an imaginary customer created specifically for the hackathon.
The store has multiple partners who contribute and sell products through the same physical location.
That creates a very practical challenge:
How do you maintain control over everyone's products and sales while still having a unified view of the business?
Collectify addresses this by connecting:
Products → Partners → Sales → Earnings → Inventory → AI
The objective is to give the people running the store a centralized place where they can understand what is happening and make better decisions.

The Idea Behind Collectify
I wanted to avoid a very common pattern in AI applications:
Inventory System
+
Generic Chatbot
=
"AI-powered" application

That was not the direction I wanted to take.
Instead, Collectify follows this model:
Business Data
↓
AI
↓
Understanding
↓
Recommendations
↓
Business Action

Sales Data
↓
AI Analysis
↓
Product Performance

Partner Data
↓
AI Analysis
↓
Individual Business Insights

Product Search
↓
AI Supplier Discovery
↓
Potential Suppliers
↓
Purchasing Decision

Product performance
Sales behavior
Inventory conditions
Partner performance
Potential restocking needs
Business opportunities

AI-Powered Supplier Discovery
One of the most important AI workflows in Collectify is supplier discovery.
A user can search for something like:
"Funko Pokémon"

Supplier name
Description
Category
Location
Website
Relevance
Rating when available
Verification information when available
Supplier tags The frontend then consumes those results and renders them as supplier cards. This distinction is important. The AI is not only generating language. It is generating structured information that the application can use. User ↓ Supplier Search ↓ FastAPI ↓ AI / Supplier Discovery ↓ Structured Results ↓ Angular ↓ Supplier Cards

AI Is a Business Tool, Not a Decoration
This is probably the most important design decision behind Collectify.
I did not want to be able to say:
"My inventory application has AI."

I wanted to be able to say:
"The AI changes what the application can do."

Product ownership
Individual inventory
Sales associated with products
Partner information
Earnings
Business performance Instead of having one large inventory with no context, Collectify creates a more structured representation of the business.

Inventory Management
Collectify provides the operational foundation required by the AI layer.
Products can contain information such as:

Name
Description
Category
SKU
Cost
Sale price
Stock
Status
Ownership The inventory is not intended to be the final product. It is the data foundation that allows the rest of the platform to work. [ESPAÑOL — AQUÍ AGREGA LA IMAGEN DEL DASHBOARD] Coloca aquí public/dashboard/dashboard.png. Sales and Earnings Sales are connected to products and business information so that the platform can later analyze what is happening. The earnings section provides another layer of visibility into the operation.

The application should be able to evolve as models evolve.
That means being able to:

Experiment with different models.
Replace providers.
Test different AI capabilities.
Adapt the AI layer without redesigning the entire application.
Run the core application locally. An AI-first application should not necessarily mean being locked into one model forever. Evidence of the AI Workflow The screenshots below document the actual development and functionality of the AI features.

Technology Stack
Frontend

Angular
TypeScript
SCSS
Angular HttpClient
Responsive UI Backend
Python
FastAPI
Pydantic
Uvicorn
REST API Database
Supabase
PostgreSQL AI
OpenRouter
Open/open-weight AI models
AI-powered business analysis
Structured AI supplier discovery Deployment
Vercel
Render
Supabase Architecture ┌─────────────────────────┐ │ Collectify │ │ Angular Frontend │ └────────────┬────────────┘ │ HTTP/REST │ ▼ ┌─────────────────────────┐ │ FastAPI Backend │ │ │ │ Products │ │ Sales │ │ Partners │ │ Earnings │ │ AI Analysis │ │ Supplier Discovery │ └────────────┬────────────┘ │ ┌──────────┴──────────┐ │ │ ▼ ▼ ┌──────────────────┐ ┌──────────────────┐ │ Supabase │ │ OpenRouter │ │ PostgreSQL │ │ AI Models │ └──────────────────┘ └──────────────────┘

Running Locally
Clone the repository:
git clone https://github.com/Ezequie1Sc/collectify.git

Install the frontend dependencies:
cd frontend/collectify
pnpm install

Run the frontend:
pnpm start

The Angular application will be available at:
http://localhost:4200

For the backend:
uvicorn app.main:app --reload

The API will run at:
http://127.0.0.1:8000

Health check:
http://127.0.0.1:8000/health

Spreadsheets
Messages
Notebooks
Manual records
Different applications
Conversations between partners The problem is not necessarily the lack of data. The problem is the lack of understanding. Collectify attempts to create a bridge between operational data and business decisions. Inventory ↓ Sales ↓ Business Data ↓ AI ↓ Insights ↓ Recommendations ↓ Action

The project combines:

Inventory management

Multi-partner management

Sales and earnings

AI analysis

AI-powered supplier discovery

Sales forecasting
Automatic restock recommendations
Partner-specific analytics
Supplier comparison
Purchase recommendations
Profitability analysis
Automated business insights
Role-based access control
Advanced dashboards
More open-weight AI models
More autonomous AI workflows The long-term goal is to move from: Inventory Management

towards:
AI-Powered Business Intelligence
for Small Retail Businesses

I started with:
"What problem does this business actually have, and where can AI genuinely help?"

That question shaped the entire project.
AI should not be decoration. It should solve a real problem.

Hi

Orlando Ezequiel Salazar Cruz — Mon, 05 Oct 2026 04:02:09 +0000

DEV Community: Orlando Ezequiel Salazar Cruz

Listify AI — Create Better Product Listings with Open-Weight AI

hacktoberfest #opensource #ai #webdev

Listify AI — Turning Simple Product Details into Better Listings with Open-Weight A

hacktoberfest #opensource #ai #webdev*This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle*

Benchmarking Free AI Models for Outdoor Adventure Generation

What I Benchmarked

Models Tested

Findings

My Benchmark

kagglechallenge

🌿 Ruta Viva AI: Turning Everyday Walks into AI-Powered Adventures

Collectify: AI-Powered Inventory Management for Smarter Business Decisions

Inventory management

Multi-partner management

Sales and earnings

AI analysis

AI-powered supplier discovery

Collectify: Building an AI-First Business Platform for a Real Local Store

Inventory management

Multi-partner management

Sales and earnings

AI analysis

AI-powered supplier discovery

Hi

hacktoberfest #opensource #ai #webdevThis is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle