PitchPilot

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

What I Built

I built PitchPilot, a local AI assistant that helps freelancers and solo creators turn rough client notes into polished project proposals, scope documents, estimates, and follow-up messages.

The problem is simple: doing the actual work is often easier than selling the work.

A freelancer might receive something like:

Need a landing page for our new product.
Probably 5 sections.
Need it by next Friday.
We already have branding.
Budget around $800.

PitchPilot turns that into a structured draft containing:

• project summary
• deliverables
• scope boundaries
• estimated timeline
• pricing breakdown
• assumptions
• revision limits
• suggested next steps
• client follow-up message

Instead of spending 30–60 minutes writing a proposal from scratch, the freelancer gets a usable first draft in seconds and only needs to review it.

The people who could pay for it are freelancers, consultants, developers, designers, marketers, photographers, and other solo service businesses that repeatedly write proposals for potential clients.

The business model could be a simple one-time paid desktop app instead of another monthly AI subscription.

Demo

The demo starts with an intentionally messy client request:

Shopify store redesign.
Around 12 products.
Client wants something cleaner and faster.
Need mobile optimization.
Maybe newsletter setup too.
Budget is around $1,500.
Would like it done in three weeks.

PitchPilot converts it into a structured proposal containing a clear scope, milestones, deliverables, estimated price, exclusions, and a ready-to-send client message.

Because inference runs locally, the client brief never needs to leave the freelancer's computer.

Demo:

[ADD YOUR DEMO / VIDEO LINK HERE]

Code

PitchPilot is open source and designed to run locally.

Repository:

[ADD YOUR GITHUB REPOSITORY HERE]

A typical setup looks like:

git clone [YOUR_REPOSITORY]
cd pitchpilot

pip install -r requirements.txt

ollama pull qwen3:4b

python app.py

No AI API key is required.

Once the model is downloaded, proposal generation can run locally.

How I Built It

PitchPilot uses Ollama for local inference and an open-weight Qwen3 model as its reasoning and writing engine.

The application takes an unstructured client brief and combines it with information such as:

Service: Web development
Hourly rate: $60
Minimum project: $500
Revisions included: 2
Typical delivery: 2-4 weeks

Instead of asking the model to generate one giant block of text, PitchPilot first generates structured proposal data.

For example:

{
  "project_title": "Shopify Store Redesign",
  "deliverables": [
    "Responsive Shopify storefront redesign",
    "Mobile optimization",
    "Product page improvements",
    "Newsletter signup integration"
  ],
  "timeline": "3 weeks",
  "estimated_price": 1500,
  "revisions": 2
}

The application validates that structure and then turns it into the final client-facing proposal.

I separated the project into a few simple layers:

Client Brief
     ↓
Open-Weight Model
     ↓
Structured Proposal
     ↓
Validation
     ↓
Proposal / Estimate / Client Message

The model is also configurable.

For example:

python app.py --model qwen3:4b

can be changed to another locally installed compatible model.

That means users are not locked into the model I originally selected.

The open model is not just an extra feature. It handles the main value of the application: understanding an incomplete client request and converting it into a professional business document.

Why Does Open Innovation Matter?

Open innovation matters here because freelancers regularly work with information that should not automatically be sent to an external AI provider.

A client brief might contain:

Unreleased product details
Internal company problems
Customer information
Pricing
Budgets
Credentials
Contract requirements
Business strategy

With PitchPilot, that information can stay on the freelancer's own machine.

That is particularly important for freelancers working under NDAs or handling confidential client projects.

Running an open-weight model also changes the economics.

If someone generates dozens of proposals every month through a paid API, every generation has a cost.

With local inference, the user can download the model once and keep using it without paying for every proposal.

It also gives me control over the product.

I can:

• change the system prompt
• add industry-specific proposal styles
• switch models
• run smaller models on lightweight hardware
• use larger models when more compute is available
• fine-tune a model for a particular profession
• build offline workflows
• avoid depending on one AI vendor

A closed API could generate proposals too.

But an open-weight model makes it possible to build PitchPilot as a tool the freelancer can actually own rather than another service they permanently rent.

For a project aimed at helping people make money from their skills, that difference matters.

My Agent Session

I used an AI-assisted development workflow while designing PitchPilot, particularly for exploring the architecture, defining the structured-output format, improving the local inference workflow, and thinking through the freelancer experience.

DevRelay session:

[ADD YOUR DEVRELAY SESSION HERE]