ScopeCheck: An Air-Gapped Scope Creep & Contract Auditor for Freelancers

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

What I Built

ScopeCheck is an offline, air-gapped auditor that evaluates client revision requests, late-stage change emails, and Statement of Work (SOW) terms without letting a single byte of client data leave your laptop.

Almost every independent developer knows this exact message pattern near a milestone delivery:

"The dashboard looks great! While you have the repo open, could you quickly wire up Stripe, user auth, and PDF export before tomorrow? It should only take a few minutes since the UI is done."

When that lands in your inbox, you usually have two bad choices:

1. Absorb 10+ hours of unbilled architectural labor just to keep the client happy.
2. Draft a blunt, defensive response that strains the relationship right before milestone sign-off.

Pasting a client's proprietary technical spec or signed contract into commercial cloud AI tools isn't an option either—doing so leaks unreleased business logic and breaches confidentiality agreements.

ScopeCheck gives freelancers a safe third option. You paste the client's message into a local studio interface, and it gives you:

• A Severity Rating (1–10): An immediate diagnosis of how far the request steps outside standard delivery boundaries.
• Architectural Flagging: Calls out the actual technical debt hiding behind innocent wording (e.g., distinguishing between a CSS tweak and new database migrations or payment webhooks).
• A Pushback Draft: Generates a polite, firm negotiation script that validates the idea while framing additions as Phase 2 deliverables with separate pricing.

Freelancers and boutique technical agencies lose thousands of dollars every year to unpaid scope creep. ScopeCheck catches that creep before work starts.

Demo

ScopeCheck runs locally via Ollama to guarantee client text never hits external servers.

1. Ingestion & Model Selection

Paste raw emails, Slack messages, or contract clauses directly into the interface:

2. Breakdown & Negotiation Draft

When auditing a typical "quick revision" asking for payment hooks and logins, the local engine flags the unbilled work and drafts a clear response:

Code

Razorbillworks / scopecheck

Local, zero-leak scope creep and contract auditor for freelancers powered by Gemma.

🛡️ ScopeCheck

An air-gapped, local contractual and scope-creep auditor built for freelance engineers, technical consultants, and boutique digital agencies. Powered by local Google Gemma inference via Ollama.

Built for the Hacktoberfest Open-Source AI Challenge: Week 2 (Side Hustle Track).

---

The Real Problem with Freelance "Quick Revisions"

Every independent developer or agency freelancer knows this exact message pattern:

"The dashboard looks super clean! Hey, while you still have the codebase open, could you quickly wire up user authentication, Stripe webhooks, and an export-to-PDF button before tomorrow? Should only take a few minutes since the UI is already finished!"

When this happens, freelancers are caught in a bad trade-off:

1. Eat the cost: Do 10+ hours of unpaid architecture, backend plumbing, and QA to avoid an awkward confrontation.
2. Burn the bridge: Send a blunt, defensive email that strains client relations right before milestone sign-off.
3. Leak client data to cloud AI: Paste the…

View on GitHub

• Repository: https://github.com/Razorbillworks/scopecheck
• License: Apache 2.0

How I Built It

• Local Reasoning Engine: Google Gemma (gemma2:2b / gemma3:4b). Gemma's instruction following is remarkably sharp at dissecting contract nuances and technical requirements without hallucinating clauses that don't exist.
• Runtime: Connected directly to Ollama via local loopback (localhost:11434), eliminating external API calls and third-party prompt caching.
• Interface: Built with Python 3.10+ and Streamlit, styled with an editorial slate-obsidian layout designed for reading dense contracts cleanly.
• Prompt Architecture: The audit harness strictly separates risk calculation from diplomatic script drafting so the model doesn't blend technical debt with negotiation pleasantries.

Why Does Open Innovation Matter?

Most side hustles and freelance agencies operate under strict non-disclosure agreements (NDAs).

When you paste an unreleased product brief, API structure, or signed agreement into a proprietary cloud AI service, you lose control of that data. Closed platforms routinely log inputs, retain telemetry, and use prompts for future training cycles. For a contractor, that is an immediate legal liability.

Open innovation is what makes an offline auditor viable:

1. True Data Sovereignty: Gemma runs entirely inside your machine's RAM. Zero outbound network calls means client NDAs stay completely intact.
2. Predictable Unit Economics: Closed APIs charge variable per-token fees that add up fast with long documents. A local open model costs exactly $0.00 to run.
3. No Vendor Lock-In: You don't have to worry about sudden API rate limits, deprecations, or outages while traveling or working on restricted client networks.

Prize Categories

• Best Use of Gemma: ScopeCheck uses local Google Gemma models (gemma2:2b / gemma3:4b) as its primary analytical engine. Gemma's reasoning ability isolates technical deliverable creep, parses ambiguous client communications, and drafts commercial pushback scripts—all running efficiently on standard developer hardware.