PitchCraft Local — A Freelance Proposal Generator That Runs Locally

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

What I Built

PitchCraft Local is a command-line tool that turns a client's brief into an editable freelance proposal with itemized pricing — powered by a local open-weight AI model.

Freelancers often spend time translating vague client requirements into a clear scope of work, estimating hours, calculating costs, and preparing professional proposals. PitchCraft Local helps streamline that process without requiring a paid AI subscription or cloud-based LLM API.

Here's what it does:

• Generates proposals: Converts a client's brief into a structured scope of work, estimated hours, and project phases.
• Calculates pricing independently: Uses deterministic Python calculations and decimal-based arithmetic instead of trusting the model to calculate money.
• Supports editable output: Produces Markdown proposals alongside structured JSON for review and further processing.
• Flags uncertainty: Highlights unknown services, missing information, and estimates that need human confirmation.
• Keeps inference local: Uses Ollama with Qwen 2.5 3B, with no external inference API or application telemetry.

The target users are independent freelancers, solo developers, and small service businesses that repeatedly prepare project quotations.

The goal isn't to replace a freelancer's judgment. It's to reduce repetitive drafting and arithmetic so they can focus on scope clarification, realistic estimates, and client communication.

Demo

The repository includes screenshots of the CLI running locally, including model readiness checks, generated proposals, and tests.

• View the local demo screenshots and details
• Read the demo documentation
• See the verification notes

The project runs from a terminal and is designed for resource-constrained hardware, including an Intel i3 machine with 8 GB RAM. CPU inference may be slow, depending on the brief and machine.

Code

GitHub repository: GhananilShirpurkar/pitchcraft-local

The project is written in Python and includes a CLI, configurable service catalogue, example client briefs, offline tests, and an evaluation runner.

Start with the repository README for installation instructions and a complete walkthrough.

How I Built It

I built PitchCraft Local around Python, Ollama, Qwen 2.5 3B, Pydantic, and deterministic pricing logic.

I deliberately chose a small local model because my development machine has an Intel i3 processor and 8 GB of RAM. Instead of relying on a large hosted model, I wanted to explore how useful a constrained, locally running model could be for a specific business workflow.

The pipeline looks like this:

1. Input: A client brief and the freelancer's configured service catalogue, rates, and terms.
2. Local inference: Qwen 2.5 3B drafts the project scope, estimates hours, and organizes the work.
3. Validation: Pydantic validates the proposal structure, while application logic checks catalogue references and flags unknown services.
4. Pricing: Python resolves the applicable rates and computes monetary amounts using Decimal arithmetic.
5. Output: The application generates Markdown and JSON files for the freelancer to review and edit.

A key design decision was to keep financial calculations outside the model. An LLM can help interpret a brief, but it shouldn't be trusted to perform authoritative pricing arithmetic.

I also added bounded inference attempts, offline tests, loopback-only runtime communication, and safeguards against treating client-provided text as trusted instructions.

The project is an MVP, not a production-ready commercial product. Its generated scope, estimates, and wording still require human review.

Why Does Open Innovation Matter?

Open innovation made it possible to experiment with an AI-powered business tool without depending on a proprietary inference API.

Using an open-weight model through Ollama gave me control over the runtime, the inference configuration, and how data moves through the application. It also let me build and test the workflow on modest hardware instead of designing around an expensive hosted model.

More importantly, this project explores a practical engineering question: How much of a useful AI product can be built with a small local model when the surrounding software is designed carefully?

The answer isn't that the model can do everything. It's that the model can handle language-heavy drafting while conventional code handles validation, pricing, file safety, and predictable business rules.

That separation makes the application easier to test, inspect, and improve.

One important caveat: the repository's MIT license covers the project code, not the model weights. The selected Qwen 2.5 3B model uses a separate Qwen Research License, which must be reviewed for the intended use.

My Agent Session

I haven't included a DevRelay agent-session link in this submission. The repository and its implementation are available above.

Prize Categories

Primary fit: Side Hustle — a practical tool aimed at helping freelancers reduce repetitive proposal preparation.