I Built ScopePilot: An AI-Powered Proposal Generator Using Gemma 3 That Runs Locally

A developer built ScopePilot, an open-source, local-first proposal and project-scoping assistant that turns unstructured client briefs into structured, editable proposals. The tool runs Gemma 3 1B locally through Ollama's REST API, validates model output with Pydantic schemas, and handles pricing calculations deterministically in Python rather than relying on the model's arithmetic. It offers a local mode with real inference and a public Streamlit demo using bundled sample proposals, with exports to PDF and Markdown.

Freelancing isn't just about doing the actual work. Before a project even begins, freelancers often spend hours understanding client requirements, defining deliverables, estimating costs, planning milestones, and writing professional proposals. And the problem? A client brief is rarely perfect. Sometimes it's just a few sentences in an email. Sometimes it's a long document with unclear requirements. Turning that into a structured, professional proposal takes time that freelancers could spend doing paid work. I wanted to build something to make that process easier. Meet ScopePilot — a local-first AI-powered proposal and project-scoping assistant. What I Built ScopePilot transforms unstructured client briefs into structured, editable project proposals. It's designed primarily for: Freelancers who regularly prepare project proposals. Independent developers and designers. Small agencies and consultants. People starting their freelancing journey who need help defining project scope and pricing. Give ScopePilot a client brief, and it helps generate: - Project Analysis: Understands the client's requirements and objectives. - Executive Summary: Creates a professional project overview. - Scope & Deliverables: Breaks the project into clear deliverables and exclusions. - Milestones & Timeline: Organizes the project into manageable phases. - Pricing Breakdown: Provides indicative line-item estimates with deterministic calculations. - Risks & Assumptions: Identifies potential challenges and assumptions. - Clarification Questions: Highlights information that should be confirmed with the client. The generated proposal can be edited, selectively regenerated, saved locally, and exported as PDF or Markdown. The goal isn't to replace a freelancer's judgment. It's to reduce the repetitive work involved in preparing a proposal while keeping the freelancer in control. Demo Try the public interactive demo: https://scopepilot-dccw64jmecdaxnjleyttdb.streamlit.app/ https://scopepilot-dccw64jmecdaxnjleyttdb.streamlit.app/ The public demo uses bundled sample proposals so visitors can explore the interface, edit sample content, and test exports without installing anything. Want to experience the actual AI generation? Run ScopePilot locally using Ollama and Gemma 3 1B. The local edition supports real AI-powered proposal generation without sending client briefs to an external LLM API. Code GitHub Repository: https://github.com/sayuj5/ScopePilot https://github.com/sayuj5/ScopePilot The project is open source. You can explore the implementation, run it locally, and contribute. How I Built It The central idea behind ScopePilot was to make open-weight AI the actual engine of the application, rather than adding an AI feature just for the sake of it. The AI Engine I chose Gemma 3 1B, running locally through Ollama. The application communicates with Ollama through its local REST API. The model processes client briefs through a structured generation pipeline. I use Pydantic schemas to validate the generated output and Python services to handle proposal generation, pricing calculations, validation, and storage. The model assists with understanding requirements and generating proposal content. Pricing calculations are handled deterministically in Python rather than blindly trusting the model's arithmetic. Technology Stack AI Model: Gemma 3 1B Local Inference: Ollama Backend & Application Logic: Python User Interface: Streamlit Data Validation: Pydantic Storage: Local JSON-based persistence PDF Generation: ReportLab Testing: Pytest Privacy-First Dual-Mode Architecture One of the most important decisions was to preserve the local-first experience while making the project accessible to people who don't want to install anything. I implemented two operating modes: 1. Local Mode Real Gemma 3 1B inference through Ollama. Local proposal storage. Full proposal generation and editing. Section regeneration. PDF and Markdown exports. 2. Cloud Demo Mode Interactive public demonstration. Bundled sample proposals. Session-only editing. Sample PDF and Markdown exports. No Ollama connection or external LLM inference. No persistent visitor proposal storage. This distinction is intentional. The hosted demo is transparent about what it can and cannot do, while the complete AI experience remains available locally. Why Does Open Innovation Matter? For this project, open innovation isn't just a technology preference. It's part of the product's business model. Imagine a freelancer using an AI proposal generator for every new client. If every proposal requires a paid API request, the operating cost can become an ongoing expense. By using Gemma 3 1B locally, ScopePilot can generate proposals without depending on a metered cloud LLM API. There are three major advantages: 1. Privacy Client briefs can contain sensitive business requirements, budgets, internal processes, and project details. Local inference allows this information to stay on the freelancer's machine. 2. Cost Control Once the model is downloaded, local inference doesn't require paying an AI API provider for every generation. This makes the core AI functionality more accessible to independent freelancers. 3. Independence ScopePilot doesn't depend on a single proprietary AI provider, its pricing changes, or its API availability. The model can be run locally, giving users more control over their tools. Open-weight models made it possible to build an AI-powered product that prioritizes privacy, affordability, and user control from the beginning. What I Learned Building ScopePilot taught me that integrating an AI model is only one part of building a useful AI product. The surrounding engineering matters just as much: Validating unpredictable model outputs. Keeping financial calculations deterministic. Handling unavailable local models. Separating confirmed requirements from AI-generated assumptions. Designing a useful interface around AI-generated content. Making privacy a core architectural decision rather than an afterthought. I also learned that a good public demo doesn't necessarily need to expose a cloud AI endpoint. It can demonstrate the product honestly while preserving the full local experience. Prize Categories I'm submitting ScopePilot for: Best Use of Gemma — Gemma 3 1B is the core model powering local AI proposal generation. I'm also entering the overall Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle. Built with Python, Streamlit, Ollama, and Gemma 3 1B.