Hacktoberfest Open-Source AI Challenge: Week 2

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

What I Built

HustlePilot AI — Less Admin. More Earning.

HustlePilot AI is an open-source, local-first business assistant designed for freelancers, independent developers, designers, students running side hustles, and small business owners. It brings essential business tasks—including proposal writing, project estimation, invoice management, client communication, and document organization—into one responsive workspace, with optional assistance from open-weight AI models.

Running a freelance business involves more than delivering great work. Writing proposals, calculating project costs, preparing invoices, following up with clients, and organizing documents can consume hours that could otherwise be spent on paid work. Many AI-powered alternatives rely on proprietary cloud services, usage-based pricing, or external processing of business information.

HustlePilot AI takes a different approach: A practical business toolkit that works independently of AI, with the option to connect to a locally hosted model for additional assistance.

Key Features

• Business Dashboard: Displays statistics derived from saved data, including proposal and invoice counts, total invoiced, payments received, outstanding balances, and overdue invoices.
• AI Proposal Generator: Creates structured proposals from user-provided project briefs, with a built-in template fallback when AI generation is unavailable.
• Project Cost Estimator: Calculates project costs using JavaScript, supporting hourly or fixed pricing, complexity-based contingency, and additional expenses. Optional AI analysis helps identify task breakdowns and potential scope risks.
• Invoice Management: Create, edit, duplicate, search, filter, and delete invoices. Manage line items, taxes, currencies, and payment statuses, and print invoices to PDF through the browser.
• Client Communication Assistant: Helps draft professional messages for client inquiries, payment reminders, project updates, and scope changes.
• Document Workspace: Search, filter, sort, and manage proposals, invoices, estimates, and communication drafts in one place. JSON backup export and import are also supported.
• Local-First Data Storage: Saves application records in the browser using localStorage, without requiring an account or application backend.
• Light and Dark Mode: Provides a consistent interface with a persistent theme preference.
• Claymorphism-Inspired UI: Uses a responsive, tactile visual design built with Tailwind CSS v4.

Who Would Pay for It?

HustlePilot AI is designed for people who want to spend less time on administrative work and more time delivering services, building products, and earning money.

For a freelancer, saving time on proposals, invoices, and client communication can make a meaningful difference. The product is designed around a recurring, practical problem rather than AI for the sake of AI.

The goal is to build something that provides enough everyday value to justify a paid offering while keeping its core functionality accessible and its AI infrastructure flexible.

Demo

• Live Demo: https://hustel-pilot-ai.vercel.app/
• GitHub Repository: https://github.com/codexxxx07/HustelPilotAi_MLH_Week2

The application can be explored without configuring a local AI model. To test actual AI-generated content, users need a running Ollama instance with a compatible model installed and configured.

Code

Repository: https://github.com/codexxxx07/HustelPilotAi_MLH_Week2

Technology Stack

• React 19 — Component-based user interface.
• Vite 8 — Development server and build tooling.
• Tailwind CSS v4 — Styling and design system.
• React Router v7 — Client-side navigation.
• Lucide React — Interface icons.
• Oxlint — Code linting.
• Browser localStorage — Local data persistence.
• Ollama HTTP API — Optional integration with locally hosted AI models.

The application code is released under the MIT License, as specified in the repository's LICENSE file. Connected AI models have their own licenses and usage conditions.

How I Built It

HustlePilot AI is a client-side single-page application built with React and Vite. Its architecture separates the interface, local data management, and AI integration to keep the application maintainable and make it easier to extend.

1. Frontend and Interface

The application uses React components and React Router to organize the landing page, dashboard, proposal generator, estimator, invoice manager, communication assistant, document workspace, settings, and about page.

A shared component library provides reusable interface elements, while a design-token-based stylesheet supports the Claymorphism-inspired visual identity and consistent Light and Dark Modes.

2. Local Data Management

Application records are stored in the browser using localStorage. Separate storage modules handle proposals, invoices, communication drafts, estimates, settings, and backups.

This architecture allows the main business tools to operate without an application backend or user account. The application also supports exporting and importing a JSON backup.

Local storage is not encrypted, so users should understand the limitations before storing sensitive information on a shared or untrusted device.

3. Open-Weight AI and Local Inference

HustlePilot AI integrates with Ollama, which allows users to run compatible models on their own machines instead of relying on a fixed, proprietary cloud AI provider.

The AI service communicates with Ollama through its HTTP API:

• GET /api/tags checks the connection and retrieves available models.
• POST /api/generate requests generated text.

The application supports configurable model and endpoint settings, with llama3.2 as the default model configuration. AI assistance is designed for proposal drafting, project estimation analysis, client communication, and document improvement.

The model runtime is separate from the application: the project does not bundle model weights. Users must install Ollama, download a compatible model, and configure the connection to generate actual model responses.

This distinction matters because the AI integration is implemented in the application, but successful inference depends on a separately installed and running model runtime.

4. AI as an Optional Enhancement

AI is not required for the application's core business functionality.

• Proposal generation can fall back to built-in templates.
• Client communication drafting provides template-based alternatives.
• Project cost calculations use deterministic JavaScript arithmetic rather than AI-generated calculations.
• Invoice management, document editing, searching, printing, and backup operations do not depend on the AI service.

This approach keeps the application useful when a model is unavailable, while allowing users to enable AI assistance when they need it.

5. Privacy and Deployment

The application does not require an application account or a dedicated backend server. Its business records are stored locally in the browser, and the default AI configuration targets a local Ollama instance.

When using local inference, the model processes requests through the user's configured local runtime. However, a user who configures a remote endpoint must consider that endpoint's data-handling practices.

The deployed website does not automatically provide every visitor with access to the developer's local Ollama instance. Users need their own compatible local setup unless a separate AI-serving architecture is provided.

Why Does Open Innovation Matter?

Open innovation matters to HustlePilot AI because the project is designed to give users more control over the tools they use to run their businesses.

Control Over AI

By integrating with Ollama and compatible open-weight models, HustlePilot AI allows users to choose their model and inference environment. They are not permanently tied to one AI provider's pricing, rate limits, or model selection.

Greater Control Over Business Data

Proposals, client details, invoices, and project estimates can contain confidential business information.

With the default local configuration, application records remain in browser storage and AI requests can be processed by a locally hosted model rather than being sent to a third-party AI provider. This gives users greater control over their data flow.

However, local storage is not encrypted, and configuring a remote model endpoint changes where AI requests are sent. Local inference should not be confused with a guarantee of complete data security.

Flexibility Without Vendor Lock-In

The AI integration is separated from the main application logic. This makes it easier to experiment with compatible models and adapt the system as open-weight AI technology evolves.

Users can choose models that fit their hardware, quality requirements, and usage preferences rather than depending entirely on a single provider.

An Application Others Can Improve

The MIT-licensed application code can be inspected, modified, and extended in accordance with the license.

Developers can improve proposal templates, refine estimation logic, add document types, enhance accessibility, or contribute support for additional models. The project provides a foundation that others can build on instead of requiring everyone to start from scratch.

Practical AI, Not AI Dependence

One of the most important design decisions is that core business operations continue to work without an AI model.

This makes the application more accessible to developers and users who cannot run a model locally, while still providing an integration point for those who want additional AI capabilities.

Being Precise About Open-Weight Models

Open-weight models are not automatically equivalent to fully open-source software. For example, the default Llama 3.2 model is distributed under the Meta Llama 3 Community License, which has its own terms and restrictions.

The application's MIT license does not replace or override the license of any connected model.

Local inference also requires suitable hardware, storage, electricity, and setup time. The objective is not to claim that open AI is always free or superior, but to make AI infrastructure more flexible, inspectable, and user-controlled.

For HustlePilot AI, open innovation means making the application extensible, keeping AI optional, and giving users meaningful choices about the technology behind their business tools.

Prize Categories

HustlePilot AI is built around open-weight models and local inference. However, the project does not currently demonstrate a verified integration with a specific challenge sponsor's technology.

The challenge lists the following categories.

Featured categories: Render, TabPFN, Tinker, Arduino, DigitalOcean, and Gemma.

Partner categories: Backboard, ElevenLabs, Entire, GitHub Copilot, Mastra, MongoDB Atlas, Sentry Agent Tracing, SerpApi, a .tech Domain, Temporal, and Tiger Data.

I will claim a partner category only if the project meets its requirements and I can demonstrate the relevant integration. Merely supporting a compatible model or mentioning a service is not sufficient evidence of eligibility.

Prize category entry: To be confirmed against the official challenge requirements and the project's actual integrations.