BidPilot: Your AI Proposal Writer That Runs on Your Laptop, Not Someone Else's Server

Shivam Mishra — Mon, 19 Oct 2026 06:28:53 +0000

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


  
    
      
      
        shivam-mishra-music
       / 
        BidPilot
      
    
    
      
    
  
  
    
 ____  _     _ ____  _ _       _
| __ )(_) __| |  _ \(_) | ___ | |_
|  _ \| |/ _` | |_) | | |/ _ \| __|
| |_) | | (_| |  __/| | | (_) | |_
|____/|_|\__,_|_|   |_|_|\___/ \__|


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…





  View on GitHub




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.

DEV Community: Shivam Mishra

BidPilot: Your AI Proposal Writer That Runs on Your Laptop, Not Someone Else's Server

What I Built

shivam-mishra-music / BidPilot

BidPilot — AI-Powered Proposal Writer for Freelancers

🧩 The Problem