DEV Community: Aayush Malve

QuotePilot AI: Turn Project Briefs into Professional Quotations with Open-Weight AI

Aayush Malve — Sat, 17 Oct 2026 06:07:35 +0000

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

What I Built

QuotePilot AI is an AI-powered quotation generator for freelancers, independent developers, designers, consultants, and small service businesses.

Preparing a quotation manually means turning a client's requirements into service line items, estimating prices, setting payment terms, and formatting a professional document. For freelancers handling multiple inquiries, this repetitive work takes time away from delivering projects.

QuotePilot turns a project brief into an editable quotation draft. It generates suggested services, quantities, indicative prices, payment terms, and notes. Users can edit the quotation, calculate totals, save drafts in their browser, and export the result as a PDF.

For example, a freelancer can enter a brief for a five-page business website and receive a structured starting quotation covering design, development, integrations, SEO, and deployment.

The intended users are freelancers and small agencies that regularly prepare client quotations and want to reduce the time spent formatting them.

AI-generated prices are estimates, not verified market rates. Users should review the scope, pricing, and terms before sending a quotation.

Demo

Live application: https://quotepilot-ai-two.vercel.app

Generated Quotation

PDF Export

Code

GitHub repository: https://github.com/aayushmalve/quotepilot-ai

The repository contains the application source, setup instructions, environment-variable example, and MIT license.

How I Built It

QuotePilot uses Next.js, React, TypeScript, Tailwind CSS, Zod, and jsPDF.

For AI-powered generation, I integrated NVIDIA's Nemotron 3 Nano Omni 30B-A3B Reasoning model through OpenRouter:

nvidia/nemotron-3-nano-omni-30b-a3b-reasoning:free

The workflow is straightforward:

A user enters a project brief.
A server-side API route sends the generation request to the model provider.
The model returns structured JSON containing proposed quotation details.
The application parses and validates the generated data.
The user reviews and edits the quotation before exporting it.

I also implemented browser-local draft persistence and PDF generation. The API credentials remain server-side rather than being exposed in client-side code.

The application uses hosted inference, not local inference. It relies on OpenRouter and its upstream providers, so free-tier capacity, rate limits, and availability can affect generation.

Why Does Open Innovation Matter?

For a small tool like QuotePilot, the cost and flexibility of the AI layer matter.

Using an open-weight model gives the project an alternative to depending exclusively on a proprietary model ecosystem. The application can experiment with compatible models through its provider configuration, while the rest of the quotation workflow remains separate from the model itself.

In the future, the model could potentially be self-hosted, fine-tuned, or replaced with another suitable model, subject to hardware requirements, implementation work, and licensing. That could give the project more control over inference costs and deployment choices as it grows.

There are trade-offs. QuotePilot currently depends on a hosted inference provider, and project information sent for generation is processed by that provider and potentially its upstream model provider. Open weights do not automatically guarantee privacy, unrestricted commercial use, or zero operating costs.

For me, open innovation makes it possible to build around a model that can be evaluated and potentially deployed in different ways, without making the entire product dependent on one proprietary model API.

What's Next?

The next priorities are improving resilience when the model provider is unavailable, gathering feedback from freelancers, and refining quotation quality based on real use.

I Built EcoBingo to Make Touching Grass a Little More Fun

Aayush Malve — Sat, 10 Oct 2026 05:05:37 +0000

I Built EcoBingo to Make Touching Grass More Fun

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

I wanted to build something that gives people a reason to put their phones down and spend a little more time outside. That's how I came up with EcoBingo.

It's an outdoor activity game built around a bingo board of small missions. Complete activities, earn points, build streaks, and take on weekly challenges.

I also added an AI Eco Coach. Tell it what you're interested in or how much time you have, and it'll generate three personalized outdoor or eco-friendly missions for you.

The goal is to make getting outside feel less like another task on your to-do list and more like something you actually want to do.

Demo

Try it yourself: https://ecobingo-game.vercel.app/

Here's the AI Eco Coach generating personalized missions:

And here's the weekly challenges and progress tracking:

Code

GitHub repository: https://github.com/aayushmalve/ecobingo

Feel free to explore the code and see how it works.

How I Built It

The app is built with Next.js, React, TypeScript, and CSS. I use browser local storage to save supported progress and preferences, so users can return to their progress on the same browser.

For the AI feature, I integrated Gemma 4 through Google's hosted Gemini API. The Eco Coach sends the user's preferences to the API and asks for three personalized missions. The server then validates the returned data before showing the missions in the app.

I'm using hosted inference rather than running the model locally, so the AI features require an internet connection and a server-side API key.

The rest of the app includes the bingo missions, points, streak tracking, weekly challenges, and progress persistence.

Why Does Open Innovation Matter?

I didn't need to train a model from scratch to experiment with AI in this project. Using Gemma let me focus on building the feature around an actual use case: helping someone decide what to do when they step outside.

Making the source code public also means other developers can explore the implementation, suggest improvements, or build on the idea themselves.

EcoBingo is a starting point, and I'd like to keep improving it. Sharing the code makes that easier than keeping the entire project to myself.

CivicLens: Turn a Civic Problem Photo into a Verified Complaint

Aayush Malve — Mon, 05 Oct 2026 05:52:27 +0000

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

What I Built

I built CivicLens for a friend who encounters civic issues daily but rarely reports them because the complaint process is too tedious.

The problem is simple: when someone notices a pothole, garbage accumulation, broken streetlight, damaged road, overflowing drain, or another civic issue, reporting it can be surprisingly difficult. They have to figure out what the issue is, describe it properly, identify where it belongs, find the right department, and then have little visibility into what happens afterward.

CivicLens turns that process into:

Take a photo → AI analyzes it → confirm the location → route the complaint → track it → verify the resolution.

A citizen can upload a photo of a civic problem and CivicLens uses Gemma 4 to identify the issue, assess its severity and confidence, extract visible evidence, describe the risk, and generate a structured civic report.

The complaint is connected to a location and routed toward the appropriate department, giving authorities a structured case they can track and act on. Once work begins, the system can use before-and-after evidence to help determine whether the issue was actually resolved.

Demo

Live Demo: https://civiclens-project.vercel.app/

The demo shows the complete CivicLens workflow from uploading a civic issue photo to AI analysis, location confirmation, and complaint management.

Code

The complete source code is available on GitHub:

https://github.com/aayushmalve/civiclens

The repository contains the CivicLens application code without API keys, environment files, or generated dependencies.

How I Built It

CivicLens is built around Gemma 4, specifically gemma-4-26b-a4b-it, for visual analysis of civic problems.

The AI analyzes uploaded images and returns structured information including:

Civic issue category
Issue title
Severity
Confidence
Visual evidence
Description
Public risk
Recommended action
Complaint report

The application is built with:

Next.js
React
TypeScript
Tailwind CSS
Gemma 4
Google GenAI SDK
EXIF GPS extraction
Browser Geolocation API
Photon geocoding
Leaflet / OpenStreetMap

The overall workflow is:

Photo evidence → Gemma 4 analysis → Location detection → Citizen confirmation → Department routing → Civic complaint → Tracking → Resolution evidence → AI verification

The MVP uses Neon PostgresSQL for complaint persistence, while the architecture can later add object storage and municipal integrations for production deployments.

Why Does Open Innovation Matter?

Using Gemma 4, an open-weight model, gives CivicLens a more adaptable AI layer.

The model can be evaluated, replaced, adapted, or deployed according to the needs and infrastructure of the application rather than making the entire civic workflow dependent on a single closed model.

This flexibility is particularly useful for civic applications, where different cities and organizations may have different infrastructure, privacy requirements, and deployment constraints.

The AI layer can also evolve independently from the reporting, routing, tracking, and resolution-verification systems.

Prize Categories

Build for a Friend