ScopeGuard Local: A Local-First AI Assistant for Freelancers Fighting Scope Creep

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

What I Built

ScopeGuard Local is an open-source, local-first AI tool that helps freelancers identify potential scope creep before a small client request turns into a much larger project.

Freelancers often hear requests like “Could you also add a customer dashboard?” or “Can we include subscription payments?” after a project has already been agreed upon. These requests can introduce additional work, time, and costs, but figuring out whether they fit the original agreement isn't always straightforward.

ScopeGuard Local helps freelance developers, designers, and small digital agencies compare new client requests against their project agreements.

Here's how it works:

• Upload an agreement: Provide a UTF-8 text file or a PDF with selectable text.
• Analyze a client request: The local AI compares the new request with the agreement.
• Review the evidence: Get an explanation and supporting quotations from the original document.
• Understand the result: Requests are classified as in_scope, potential_scope_change, or needs_review.
• Draft a change order: Generate an editable proposal, with optional AI-assisted cost and timeline estimates.
• Export the proposal: Copy it or download it as Markdown or PDF.

The important part is that ScopeGuard doesn't just return an AI-generated verdict. It checks whether its evidence quotations actually appear in the submitted agreement and flags missing or invalid evidence for human review.

Who would pay for this? Freelancers, independent developers, designers, and small agencies who want to spend less time handling scope disputes and preparing change requests. The project is currently an open-source MVP, not a paid product.

Demo

ScopeGuard Local currently runs on your own machine, with a React frontend, FastAPI backend, and local inference through Ollama.

To try it, follow the setup instructions in the repository README. You'll need Python, Node.js, Ollama, and the Gemma 3 4B model.

The repository includes synthetic sample agreements and requests that you can use to explore the workflow without uploading real client contracts.

A hosted demo or video walkthrough is not currently linked here.

scopeguard.mp4 - Google Drive

drive.google.com

Code

GitHub repository:

Kush05Bhardwaj / ScopeGuard

A local-first assistant for comparing client requests with an agreed project scope.

ScopeGuard

ScopeGuard helps freelancers compare a new client request with a project agreement, review the supporting passages, and prepare an editable change-order proposal. The current workflow uses a local FastAPI service and Ollama by default.

What works today

• Upload UTF-8 .txt agreements or text-based .pdf agreements. PDF text keeps page references. Uploads are parsed in memory; scanned PDFs are not OCR processed.
• Compare a client request with the agreement using Ollama and Gemma 3 4B.
• Review one of three classifications: in_scope potential_scope_change, or needs_review.
• Check the model's evidence quotations against the original agreement text Missing or invented evidence requires human review. Exact quotations do not prove that the model interpreted them correctly.
• Generate a change-order proposal from the validated analysis, edit it in the browser, then copy it or download it as Markdown or PDF. The local model can suggest rough costs and timelines for missing values…

View on GitHub

ScopeGuard Local is open source under the MIT License.

The repository includes the frontend, backend APIs, analysis and reporting services, automated backend tests, documentation, and synthetic sample data.

Contributions, bug reports, and feedback are welcome!

How I Built It

The application combines a web interface, a Python API, and an open-weight language model running locally.

Technology stack:-

• Frontend: React, Vite, and TypeScript
• Backend: Python and FastAPI
• Local AI inference: Ollama with Gemma 3 4B
• Document processing: PyMuPDF for extracting text and page references from PDFs
• Validation: Pydantic for structured request and response validation
• Exports: Editable Markdown proposals and PDF downloads

The core workflow follows five steps:-

• Extract text from the uploaded agreement.
• Send the agreement text and client's new request to the local model.
• Validate the model's structured response and check its evidence quotations against the source text.
• Generate a change-order draft based on the validated analysis.
• Let the freelancer review, edit, and export the result.

The model is treated as an untrusted component. If its output is malformed, evidence is missing, or the request is ambiguous, the application can require further review rather than presenting an unsupported conclusion as fact.

ScopeGuard can also ask the local model for rough cost and timeline suggestions when those details are missing. These suggestions and their assumptions need to be reviewed by the freelancer before sharing a proposal.

The current version does not include OCR for scanned PDFs, persistent project history, authentication, or automatic client communication. It is deliberately focused on the core workflow.

Why Does Open Innovation Matter?

Open innovation matters here because a tool dealing with client agreements should give users control over how their documents are processed.

By building around open-source components and a locally run open-weight model, ScopeGuard Local can operate without requiring a proprietary hosted AI API for its default inference workflow.

That makes a few things possible:-

• More control over documents: Agreement text can remain on the user's machine when the application is configured to use local services.
• Lower dependence on a hosted AI provider: Users can run their own inference setup and configure a compatible Ollama model.
• Inspectable implementation: Developers can examine how prompts, evidence validation, API routes, and proposal generation work.
• Room for community contributions: Others can improve document parsing, model validation, accessibility, testing, and supported workflows.

Local-first operation is not an automatic privacy guarantee. Configuring services to use a remote host may send document contents to that host, and model-generated analysis can still be incorrect. Users should review results and avoid uploading confidential agreements to services they don't trust.

For this project, open innovation is about more than using an open model. It is about making the workflow, its limitations, and its safeguards inspectable and improvable.

Final Thoughts

Scope creep is a small problem that can become expensive over time. My goal with ScopeGuard Local is to give freelancers a practical starting point for evaluating new requests, finding relevant agreement text, and preparing clearer conversations about additional work.

It's an MVP, and there is still plenty to improve. Feedback on the analysis workflow, evidence validation, usability, and local model support would be especially valuable.

Try the project, explore the code, and let me know what you'd improve next!