This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle.
What I Built
Freelancers know the situation: a client asks for one additional feature, then another, until a small project quietly becomes much larger than the original agreement.
I built ScopeSentry Local, a local-first AI assistant designed to help freelancers identify potential scope creep before it becomes a difficult client conversation.
Instead of simply asking a chatbot whether a request is out of scope, ScopeSentry compares the new request against the freelancer's original, approved project agreement.
It produces one of three assessments:
- INCLUDED — the agreed scope supports the requested work.
- POTENTIAL SCOPE CHANGE — the request appears to add work or conflict with an explicit limitation.
- NEEDS CLARIFICATION — the agreement is too ambiguous to support a reliable conclusion.
The result includes an explanation, supporting quotations from the original agreement, warnings when evidence cannot be verified, and a professional response draft that the freelancer can edit before sending.
The people this is built for are independent developers, designers, and small agencies who need to manage changing client expectations without spending hours reviewing their agreements manually.
The business idea is straightforward: if the tool helps a freelancer avoid an expensive misunderstanding or an unnecessary round of unpaid work, it could be worth paying for. That willingness to pay still needs to be tested with real users.
Demo
Try ScopeSentry Local: https://scopesentry.pages.dev/
The hosted demo lets you explore the interface. Live local-model inference requires the local application setup, including Ollama and a compatible installed model. Prerecorded demo examples should not be mistaken for live AI-generated results.
Code
GitHub repository: [https://github.com/Afnan-0206/scopesentry-local]
The project uses React, TypeScript, Node.js, Express, Ollama, and Zod. The repository will include the implementation, setup instructions, and automated tests.
How I Built It
I wanted ScopeSentry to be more than a chat interface with a prompt asking an AI whether a client request was included in a contract.
The application needed a repeatable workflow, structured information about the original agreement, and evidence that a freelancer could inspect.
The main technologies are:
- React, Vite, and TypeScript for the frontend.
- Node.js and Express for the backend.
- Ollama for running models locally.
- Qwen2.5 as the initial open-weight model family.
- Zod for validating structured inputs and outputs.
- A deterministic evidence-verification layer to check quotations against the original agreement.
- Browser localStorage for project information and assessment history.
The workflow starts with an original project agreement. The model extracts deliverables, inclusions, exclusions, constraints, and ambiguous terms. The freelancer reviews and approves the extracted scope before using it for comparisons.
When a new request arrives, the backend compares it against that approved scope and returns a structured assessment. Before any quotation is presented as verified evidence, application code checks whether the quoted text actually exists in the original agreement.
This matters because a language model can produce a convincing explanation and still invent a quotation. ScopeSentry is designed to flag that failure rather than blindly trust the model.
I also included safeguards intended to prevent invented fees and deadlines in reply drafts, plus handling for unavailable models, invalid outputs, and prompt-injection attempts in supplied documents.
During local validation, the build session reported 32 automated tests passing across the backend and frontend, along with successful build, lint, and TypeScript checks. A local Ollama smoke test also returned valid JSON using Qwen2.5:0.5b.
Those results are useful engineering checks, not proof that every scope classification will be correct. Real-world evaluation is still needed.
Why Does Open Innovation Matter?
Client agreements can contain sensitive information: names, requirements, project details, and commercial terms.
For its local workflow, ScopeSentry sends inference requests to Ollama running on the user's own machine instead of requiring a proprietary cloud LLM API.
That creates several practical advantages.
Privacy and control: When inference runs locally, agreement text does not need to be sent to an external AI provider. This does not protect against every device-security risk, but it gives users greater control over where their documents are processed.
Cost control: The local workflow does not incur a per-request fee from a proprietary AI API. Hardware, electricity, and setup still have costs.
Model flexibility: Users can experiment with compatible open-weight models and choose a balance of quality, speed, and resource usage that suits their computers.
Inspectability: The prompts, source-verification logic, validation rules, and application code can be inspected and improved.
A closed API is not inherently incapable of supporting privacy or reliable output. The difference here is that local inference lets ScopeSentry make local processing a core architectural choice rather than depending on a hosted model provider.
The open-weight model supplies the language understanding, but deterministic application code adds another layer of protection by checking evidence independently.
What Still Needs to Be Proven
ScopeSentry is a working product implementation, but it is not yet a validated business.
The next steps are to test it with freelancers using real or anonymized agreements, measure how often its classifications and evidence are correct, investigate failure cases, and learn whether people would pay for it.
The tool is intended to assist with scope management, not make binding contractual or legal determinations. Users must review its evidence and make their own decisions.
I built this because I believe open-weight AI is most interesting when it solves a specific, everyday problem—not just when it makes an impressive demo.
If you work independently, I'd love to know: Would you trust a local AI assistant to help manage scope creep, and what would it need to get right before you'd use it with a real client?
Top comments (0)