This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
What I Built
Last Tuesday, I timed myself writing a proposal for a Django REST API gig on Upwork.
37 minutes.
Thirty-seven minutes to read the job description, research the client, draft something personalized, proofread it, second-guess my tone, and finally hit send. And that was a good day β some proposals take an hour when the scope is complex.
I apply to roughly 15 jobs a week. That's 9+ hours per week just writing proposals. Not coding. Not designing. Not doing any of the work I'd actually get paid for. Just⦠bidding.
So I built BidPilot.
BidPilot is an AI-powered proposal writer purpose-built for freelancers. You paste a job posting from Upwork, Fiverr, or any freelance platform, and it:
- Analyzes the job β extracts requirements, identifies the client's pain points, detects budget signals, and reads tone cues (formal? casual? urgent?)
- Generates a personalized proposal β not a generic template, but a response that directly addresses what this specific client needs to hear
- Scores the proposal β rates it on relevance, tone, completeness, and persuasion, then suggests concrete improvements The entire pipeline runs 100% locally on your laptop using Google's Gemma model. No cloud APIs. No internet required (after the one-time model download). No subscription fees. ### The Side Hustle Math Here's why this could charge $9/month and still be a no-brainer:
- A freelancer earning $50/hr spends ~30 min per proposal = $25 of time per proposal
- At 15 proposals/week, that's $375/week in time spent just bidding
- BidPilot cuts proposal time to ~30 seconds
- ROI: $375/week saved for $9/month β that's a 166x return But I'm not charging anything. BidPilot is open source and runs on your own hardware. The "business model" is that freelancers keep more of their time β and their data stays on their machine. ## Demo π GitHub Repository β BidPilot BidPilot runs locally, so the best demo is running it yourself. It takes under 5 minutes:
bash
# 1. Install Ollama (one-time)
curl -fsSL https://ollama.com/install.sh | sh
# 2. Pull Gemma (one-time, ~2.5 GB)
ollama pull gemma3:4b
# 3. Clone and run
git clone https://github.com/shivam-mishra-music/BidPilot.git
cd BidPilot
pip install -r requirements.txt
python app.py
Open http://localhost:7860 and paste any job posting. That's it.
Don't have Ollama installed? Run python app.py --demo to explore the full UI with pre-generated sample outputs β no model download needed.
Code
____ _ _ ____ _ _ _
| __ )(_) __| | _ \(_) | ___ | |_
| _ \| |/ _` | |_) | | |/ _ \| __|
| |_) | | (_| | __/| | | (_) | |_
|____/|_|\__,_|_| |_|_|\___/ \__|
BidPilot β AI-Powered Proposal Writer for Freelancers
Write winning freelance proposals in seconds. 100% local. 100% private. 100% free.
𧩠The Problem
Every freelancer knows the grind: you find a promising job on Upwork or Fiverr, and then spend 30+ minutes crafting a proposal tailored to that specific posting. Multiply that by 10β20 applications a week and you're burning hours just bidding β not even doing billable work.
BidPilot cuts that to 30 seconds.
Paste a job posting, and BidPilot analyzes the client's requirements, identifies their pain points, and generates a personalized, professional proposal β all running locally on your laptop with zero APIβ¦
How I Built It
The Core Insight
Most "AI proposal writers" are thin wrappers around ChatGPT with a system prompt. They produce generic, obviously-AI-generated text that clients can spot from a mile away. I wanted something different: a pipeline that understands what makes a proposal win.
After analyzing 200+ of my own successful proposals, I noticed a pattern. Winning proposals do three things:
Mirror the client's language β if they say "scalable backend," you say "scalable backend," not "robust server infrastructure"
Name the pain β show you understand why they're hiring, not just what they need built
Reduce perceived risk β mention relevant experience, suggest a first milestone, offer a brief discovery call
BidPilot's three-stage pipeline is designed around these principles.
Architecture
Job Posting (raw text)
β
βΌ
ββββ Stage 1: Job Analysis ββββ
β Extracts: β
β β’ Hard requirements β
β β’ Desired skills β
β β’ Client pain points β
β β’ Budget signals β
β β’ Communication tone β
ββββββββββββββββ¬ββββββββββββββββ
β Structured JSON
βΌ
ββββ Stage 2: Proposal Gen βββββ
β Generates personalized β
β proposal using analysis β
β context + user profile β
ββββββββββββββββ¬ββββββββββββββββ
β Draft proposal
βΌ
ββββ Stage 3: Quality Score ββββ
β Rates on 4 dimensions: β
β β’ Relevance (0-10) β
β β’ Tone match (0-10) β
β β’ Completeness (0-10) β
β β’ Persuasion (0-10) β
β + Specific suggestions β
ββββββββββββββββββββββββββββββββ
Tech Stack
Gemma 3 4B via Ollama β The heart of the system. Gemma's instruction-following capability is remarkably good at 4B parameters β small enough to run on a laptop with 8 GB RAM, sharp enough to produce proposals that don't read like a robot wrote them. I tested Gemma 2B (too generic), Gemma 7B (great but slow on consumer hardware), and landed on 4B as the sweet spot.
Ollama β Makes local model inference trivially easy. One ollama pull and you have a model running with an OpenAI-compatible API. No CUDA setup, no dependency hell, no PhD required.
Gradio β I wanted a clean web UI that anyone could use β not just developers comfortable with terminals. Gradio gives me a polished interface with about 50 lines of UI code. The tabbed layout separates analysis, generation, and scoring into clear steps.
Python β Orchestrates the pipeline, handles prompt engineering, and manages the conversation flow between stages. Each stage uses carefully crafted prompts that took dozens of iterations to get right.
Why Gemma Specifically?
I tested five open-source models for this project. Here's what I found:
Model Proposal Quality Speed (M2 Mac) RAM Usage
Gemma 3 4B βββββ ~8 sec ~4 GB
Llama 3.2 3B βββ ~6 sec ~3.5 GB
Mistral 7B ββββ ~15 sec ~6 GB
Phi-3 Mini βββ ~7 sec ~3.5 GB
Qwen2 7B ββββ ~14 sec ~6 GB
Gemma 3 4B hit the best balance: proposal quality on par with 7B models, but fast enough to feel interactive and light enough to run alongside your IDE and browser. The instruction-tuned variant is particularly good at following the structured output format I need for the analysis stage.
Why Does Open Innovation Matter?
I want to make a specific argument here, not a general one. Open-source AI isn't just philosophically nice β for this exact use case, it's the only approach that makes sense. Here's why:
- Privacy Isn't Optional β It's the Whole Point
When a freelancer writes a proposal, they're working with sensitive information. The job posting might include:
Client company names under NDA
Proprietary technical architecture details
Budget information meant only for applicants
Project specs that are trade secrets
Every SaaS proposal tool sends this data to external servers. Most freelancers don't think about it. But if you're writing proposals for enterprise clients β the kind that pay $100+/hr β your clients will think about it. One data breach at a SaaS provider and your client's confidential project details are in the wild.
With BidPilot, the data never leaves localhost. There's no server to breach because there's no server.
- $0/Month Changes the Economics
Freelancing is a business with thin margins in the early years. The average Upwork freelancer earns $3,000β5,000/month. When you're in that range, every SaaS subscription matters:
Jasper AI: $49/month
Copy.ai: $36/month
Generic "AI proposal" tools: $15β30/month
That's
50
β
80
/
π
π
π
π‘
β
π
π
π
π€
π
π
π‘
π
π
π
π‘
π
π
π
π
π
π
π
π
π
.
π
π£
π
π
π
π¦
π
π
π
,
π
π‘
β²
π
50β80/monthforwritingtoolsalone.Overayear,it
β²
s600β960 β roughly a full week's income for many freelancers.
BidPilot costs the electricity to run your laptop. That's it. Open-source models mean the most powerful part of the stack β the AI itself β is free forever. Not "free tier with limits." Not "free trial for 14 days." Free.
- Your Proposals Should Make You Sound Like You
Here's the most underrated advantage: with an open-source model running locally, you can fine-tune Gemma on your own winning proposals. Collect the proposals that actually landed you gigs, create a small training set, and run a LoRA fine-tune. Now BidPilot doesn't just write generic proposals β it writes proposals in your voice, with your style, emphasizing the things your successful bids have in common.
No SaaS tool lets you do that. They give you the same model everyone else gets.
- No Vendor Lock-In, No Rug Pulls
Open-source AI means you're never one pricing change away from losing your tool. When Jasper tripled their prices in 2023, users had no recourse. When OpenAI deprecated models, applications broke overnight.
BidPilot's model layer is a single configuration line. Swap Gemma for Llama, Mistral, or Qwen in seconds. If a better model drops tomorrow, you upgrade in one command: ollama pull <new-model>. Your workflow, your data, and your fine-tuned weights all stay exactly where they are β on your machine.
Open innovation isn't just about making code available. It's about giving people real ownership of tools that affect their livelihood. For freelancers, a proposal writer isn't a toy β it's a business tool that directly impacts income. That tool should be private, free, customizable, and permanent. Open-source AI is the only way to deliver all four.
Prize Categories
Best Use of Gemma β Gemma 3 4B is the core model powering BidPilot's entire three-stage pipeline (job analysis, proposal generation, quality scoring). Chosen specifically for its instruction-following quality at a size that runs interactively on consumer hardware.
Top comments (0)