This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady
What I Built
ScopeGuard - Scope & Creep Defense
Scope creep is one of the most frustrating problems in client projects. A simple website project can gradually turn into an entirely different product through extra requests buried in emails, chats, and meeting notes.
ScopeGuard helps developers, freelancers, agencies, and project managers turn messy client conversations into clear, actionable project scope information.
It analyzes conversations to identify:
Project scope: What was originally agreed upon.
Decisions and action items: What needs to happen next.
Out-of-scope requests: New requirements that may exceed the original agreement.
Scope risks: Potential misunderstandings before they become costly disputes.
It also aims to help teams prepare evidence-based, diplomatic responses when a client requests additional work.
The goal is simple: spend less time manually reviewing conversations, reduce misunderstandings, and protect time that would otherwise disappear into unpaid work.
Demo
Try ScopeGuard here:
https://sope-guard.netlify.app/
Open the Conversation Analyzer and test it with a client email containing both original project requirements and additional feature requests.
Code
Explore the source code on GitHub:
https://github.com/Judakp/scopeguards
ScopeGuard is built as a web application, with a React and TypeScript frontend and an AI analysis service powered by a Supabase Edge Function.
How I Built It
I built ScopeGuard around Gemma, an open-weight AI model, accessed through OpenRouter.
The application uses a React and TypeScript interface to let users analyze client conversations in the context of a project. The analysis request is sent to a Supabase Edge Function, which handles the connection to the AI provider without exposing the OpenRouter secret key in the frontend.
The intended workflow is:
Select a project and provide a client conversation.
Send the conversation for AI-powered analysis.
Extract structured information about scope, decisions, and potential scope changes.
Review the findings and use them to make better-informed project decisions.
I also built the application to demonstrate the experience with realistic project scenarios, including a website redesign where a client requests features that were not included in the initial agreement.
One of the key challenges was connecting the deployed frontend to the AI service correctly. Since the application is hosted on Netlify, I routed the analysis requests directly to the Supabase Edge Function rather than relying on an Express endpoint that Netlify does not automatically run as a persistent server.
Why Does Open Innovation Matter?
ScopeGuard is built around the idea that useful AI tools should not depend entirely on a single closed AI provider.
Open-weight models such as Gemma give developers more flexibility in how they build, deploy, evaluate, and integrate AI-powered applications. They make it possible to experiment with different inference providers and deployment strategies while keeping the product's architecture under the developer's control.
For ScopeGuard, that flexibility matters because project conversations can contain sensitive business information. Having greater control over the model and inference architecture creates opportunities to explore deployment options that better fit different privacy, cost, and infrastructure requirements.
Open innovation also lowers the barrier for independent developers to build practical AI products. I was able to focus on a specific business problem and integrate an open-weight model into a working application without building a language model from scratch.
The bigger vision is to make AI useful not just for generating content, but for helping people protect their time, make better decisions, and run their businesses more effectively.
The Lazy Payoff
ScopeGuard is designed to reduce the manual work involved in reviewing long client conversations, reconstructing the original agreement, and identifying requests that may expand a project's scope.
Instead of rereading an entire email thread and manually separating agreed requirements from new demands, a project professional can use the analyzer to obtain a structured starting point for review.
The time savings have not yet been formally measured. The value I am targeting is fewer overlooked requirements, faster scope reviews, and less time spent resolving misunderstandings after they become problems.
Prize Categories
Best Use of Gemma
Top comments (2)
The tricky part with scope creep is that extra work often arrives as a casual message, not a formal change request. Catching that early could save freelancers a lot of awkward conversations later.
Exactly ! That’s one of the problems I wanted ScopeGuard to address. Scope creep rarely announces itself as a formal change request, it often starts with a simple “Could we also add…?” The earlier you can identify that shift, the easier it is to address it clearly and diplomatically.