This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
PitchPilot is an open-source AI proposal and quote generator for freelancers.
It turns an informal client brief into a complete project proposal, concise
quote, or client-facing email. The result remains editable so the freelancer
can review every claim, price, and timeline before sharing it.
Freelancers repeatedly translate client messages into scope, deliverables,
milestones, assumptions, pricing, and next steps. PitchPilot reduces that
administrative work without removing the freelancer's responsibility for the
final offer. Drafts can be copied, downloaded as Markdown, or printed and saved
as PDF.
The project fits the Side Hustle theme because it solves a focused problem
directly connected to earning freelance income. It is intended for independent
developers, designers, consultants, marketers, and other professionals who
regularly prepare project proposals.
Demo
PitchPilot is demonstrated locally so client briefs can remain on the user's
computer. The repository includes everything needed to run the demo:
git clone https://github.com/AryanSharma9917/pitchpilot-ai.git
cd pitchpilot-ai
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
ollama pull gemma3:4b
uvicorn app.main:app --reload
After starting the application, open the local address displayed by Uvicorn in
your browser.
The interface includes a Load demo details button that fills the form with
a fictional client brief. Choose Full proposal, Quick quote, or Client email,
then generate a draft. Local generation speed depends on the computer's CPU,
GPU, and available memory.
The demo workflow is:
- Confirm that the configured Gemma model is ready.
- Load the fictional example or enter a client brief.
- Select the desired output type.
- Generate and review the structured draft.
- Edit a section, then copy, download, or print the result.
Code
PitchPilot
Open-source AI proposal and quote generator for freelancers.
Turn a rough client brief into a professional proposal in minutes, with model inference through locally running Gemma and Ollama. No proprietary cloud LLM API is required.
Local inference is not the same as a blanket offline or privacy guarantee Installing Ollama and downloading the model requires internet access. A remotely configured Ollama host receives the prompt.
The problem
Freelancers repeatedly translate informal client requests into a project scope, deliverables, milestones, pricing, assumptions, and client communication. PitchPilot turns that routine drafting into a structured, editable starting point while leaving the freelancer in control of the final proposal.
What it does
- Generates a full proposal, quick quote, or client-facing email.
- Uses a configurable Ollama model, defaulting to Gemma 3 4B (
gemma3:4b). - Requests structured JSON and validates it with mode-specific Pydantic schemas.
- Makes one correction attempt if model output is malformed…
View the PitchPilot repository on GitHub
How I Built It
PitchPilot uses:
- Gemma 3 4B as the open-weight language model
- Ollama for local inference
- FastAPI for the backend API
- Pydantic for input and model-output validation
- Vanilla HTML, CSS, and JavaScript for the interface
- Pytest for automated testing
- GitHub Actions for continuous integration
The browser sends project information to the local FastAPI application. The
backend validates the request, creates a mode-specific prompt, and sends it to
Gemma through Ollama's local API.
PitchPilot requests structured JSON but does not assume every model response
will be correct. Separate Pydantic schemas validate proposals, quotes, and
emails. If Gemma returns malformed or incomplete data, the application makes
one bounded correction attempt. If the second response remains invalid, the
user receives a clear error rather than unreliable output.
The application reports whether Ollama is unavailable, the configured model is
missing, or the complete AI workflow is ready. Generated text is inserted into
the page through text-based DOM APIs instead of being interpreted as HTML.
Request-size and brief-length limits are enforced. The application rejects
missing input, unexpected response fields, blank structured values, unavailable
models, timeouts, and invalid model output. Its 27 automated tests cover request
and response validation, readiness reporting, prompt construction, JSON
extraction, correction retries, generation routes, pricing labels, error
handling, and page loading.
When the user has not supplied a budget, generated prices are explicitly
presented as estimates. The interface reminds users to verify scope, rates,
taxes, timelines, and contract terms before sending a draft.
Why Does Open Innovation Matter?
Client briefs can contain private business information. Requiring every brief
to pass through a proprietary cloud API gives users less control over where
that information is processed.
PitchPilot uses Gemma through Ollama, making it possible to run the core
generation workflow on hardware controlled by the freelancer. No proprietary
language-model API is required. Users can inspect the entire generation path,
change the configured Ollama-compatible model, and modify the prompts,
validation, and retry behavior.
Local inference is not a blanket privacy or offline guarantee. Installing
Ollama and downloading Gemma initially requires internet access. A remotely
configured Ollama endpoint receives the prompt, and local machines or reverse
proxies may have their own logging behavior.
There are practical tradeoffs: local models require compatible hardware and
storage, generation can be slower, and output quality can vary between models.
Despite those tradeoffs, open-weight models give freelancers meaningful control
over model selection, cost, deployment, and data handling.
Development Process
I used GitHub Copilot during the initial development of PitchPilot. When that
development session stopped working, I audited the repository, restored its
missing validation models, tested the complete application, and finished its
documentation and continuous-integration workflow.
The final project includes a GitHub Actions workflow that installs the
application and runs its automated tests on pushes and pull requests.
Prize Categories
- Best Use of Gemma
- Best Use of GitHub Copilot
Top comments (0)