DEV Community

Cover image for FreelanceShield AI: Local Open-Weight Scope Creep Detector & TabPFN Invoice Risk Forecaster
Robina Mirbahar
Robina Mirbahar

Posted on

FreelanceShield AI: Local Open-Weight Scope Creep Detector & TabPFN Invoice Risk Forecaster

#hf26challenge #devchallenge #ai #opensource

Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle Submission 💸

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

What I Built

Independent developers, designers, and boutique agencies lose an average of 22% of their annual income to two silent side-hustle killers:

  1. Unbilled Scope Creep ("Quick Favors"): "Hey! Can we quickly add a React Native mobile wrapper, dark mode across 14 charts, and an Okta SAML webhook before Friday's launch?"
  2. Chronic Late-Paying Invoices: Accepting net-30/net-45 terms or zero-deposit expansions from high-risk clients without data-driven payment risk visibility.

Why haven't cloud AI wrappers solved this? Because freelancers are bound by strict client NDAs. You cannot paste confidential client Statements of Work (SOWs), private Slack threads, or historical client billing ledgers into closed, third-party cloud LLM APIs without risking a breach of contract.

So I built 🛡️ FreelanceShield AI — a 100% Local-First Open-Weight Scope Creep Detector, 1-Click Change Order Generator & Prior Labs TabPFN Invoice Risk Forecaster.

FreelanceShield AI Architecture Banner

Who Would Pay For It?

  • Solo Freelancers & Side Hustlers ($19/mo Pro Desktop/Local License): Recovers an average of $1,420/month in unbilled hours on the very first caught scope expansion—delivering a 74x ROI with $0.00/month in cloud API token costs.
  • Boutique Dev & Design Agencies ($79/mo Self-Hosted Team Container on Render / DigitalOcean): Gives account managers an instant, polite, clause-grounded Change Order PDF generator + tabular cashflow risk radar across all active retainers.

Demo

What You Can Test Live Right Now:

  1. Switch Between 4 Real-World Freelancer Scope Creep Scenarios (or type your own custom SOW clauses & sneaky client Slack message):
    • 📱 "Quick Dark Mode + React Native App" (+$3,625 / 29 unbilled hrs caught)
    • 🤖 "Just Add Multi-Tenant SSO & SOC2 Questionnaire" (+$4,500 / 30 unbilled hrs caught)
    • 🎨 "5 Extra Competitor Landing Pages + 3D ProductHunt Video" (+$3,850 / 35 unbilled hrs caught)
    • ✅ Legitimate In-Scope Safari Bug Fix ($0 — Verified covered under Clause 1 & Revision Round 1)
  2. 1-Click Polite Counter-Proposal & Printable Change Order PDF (#CO-2026-089): Generates a warm, relationship-preserving reply with itemized hours, clause citations, and a printable Change Order PDF addendum.
  3. Interactive Prior Labs TabPFN Invoice Late-Payment Risk & Q4 Cashflow Chart: Simulate new invoices, switch client tiers (Seed Startup, Enterprise Net-45, Repeat VIP, Unverified Client), and watch the zero-shot tabular risk classifier adjust the recommended upfront deposit (50% vs 100% Escrow).

Code

GitHub logo RobinaMirbahar / freelanceshield-open-ai-side-hustle

FreelanceShield AI - Local Open-Weight Scope Creep Detector, 1-Click Change Order Generator and Prior Labs TabPFN Invoice Risk Forecaster (Hacktoberfest HF26 Side Hustle)

🛡️ FreelanceShield AI — Local Open-Weight Scope Creep Detector & TabPFN-3.5 Invoice Forecaster

Official Submission for the DEV Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle
Live Interactive Web App: https://robinamirbahar.github.io/freelanceshield-open-ai-side-hustle/

FreelanceShield AI Architecture Banner

💡 What Problem Does It Solve? (Why Freelancers Pay $19/mo)

Independent developers, designers, and boutique agencies lose 22% of their annual income to unbilled "quick favors" (scope creep) and late-paying invoices.

Yet freelancers cannot paste confidential client Statements of Work (SOWs), NDAs, or private Slack threads into proprietary cloud LLMs without violating strict client confidentiality clauses.

FreelanceShield AI is a local-first, open-source AI micro-SaaS side hustle that runs 100% on the freelancer's machine (or private self-hosted container):

  1. 🦙 Local Open-Weight Scope Creep Radar (Gemma 4 4B / Llama 3.2 via Ollama & In-Browser Clause Engine): Compares incoming client Slack/email requests against the signed SOW clause-by-clause—flagging out-of-scope deliverables with zero bytes of NDA leakage.
  2. 📄 1-Click…
View on GitHub

How I Built It

FreelanceShield AI combines two distinct paradigms of open-source AI—open-weight language models for unstructured contract text and a tabular foundation model for small-table financial forecasting:

+-------------------------------------------------------------------------+
|               🔒 100% LOCAL / SELF-HOSTED NDA BOUNDARY                  |
|                                                                         |
|  [Signed SOW Clauses] + [Client Slack/Email]                            |
|           │                                                             |
|           ▼                                                             |
|  🦙 Open-Weight LLM (Ollama gemma4:4b / llama3.2 + Browser Clause Diff) |
|           │                                                             |
|           ├──► 🚨 Out-of-Scope Clause Violations (+29 hrs / +$3,625)    |
|           └──► 📄 Polite Counter-Proposal & Printable Change Order PDF  |
|                                                                         |
|  [Historical Invoice Ledger CSV (5–50 rows)] + [Current Audit Features] |
|           │                                                             |
|           ▼                                                             |
|  📊 Prior Labs TabPFNClassifier (Zero-Shot Tabular Foundation Model)    |
|           │                                                             |
|           └──► 📈 >14-Day Late Payment Probability & Deposit Policy     |
+-------------------------------------------------------------------------+
Enter fullscreen mode Exit fullscreen mode

1. Local Open-Weight Contract & Clause Auditing (Ollama + Gemma 4 4B)

In agent_backend.py and app.js, FreelanceShield connects directly to a local Ollama instance (http://localhost:11434/api/generate) running gemma4:4b (or llama3.2), with an instant in-browser semantic clause-diff engine so the web demo works out-of-the-box with zero setup.

2. Zero-Shot Small-Table Invoice Risk Prediction with Prior Labs TabPFN

A solo freelancer doesn't have 100,000 rows of invoice history to train a deep neural network or tune an XGBoost pipeline—they typically have 10 to 50 past invoices in a spreadsheet (invoice_usd, net_terms_days, prior_late_count, has_scope_creep, deposit_pct, delayed_over_14d).

This small-table regime is where Prior Labs' open-source TabPFN shines! Using TabPFNClassifier in agent_backend.py, we perform in-context tabular inference in a single forward pass with zero hyperparameter tuning:

from tabpfn import TabPFNClassifier
import numpy as np

def predict_late_payment_with_tabpfn(
    invoice_usd: float,
    net_terms_days: int,
    prior_late_count: int,
    has_scope_creep: int,
    deposit_pct: float,
) -> float:
    """
    Runs Prior Labs TabPFN zero-shot tabular classification on the freelancer's
    invoice ledger to estimate the probability of a >14 day payment delay.
    """
    X_train = HISTORICAL_INVOICES.drop(columns=["delayed_over_14d"]).values
    y_train = HISTORICAL_INVOICES["delayed_over_14d"].values
    X_query = np.array([[
        invoice_usd, net_terms_days, prior_late_count, has_scope_creep, deposit_pct
    ]])

    clf = TabPFNClassifier(device="cpu")
    clf.fit(X_train, y_train)
    prob = float(clf.predict_proba(X_query)[0][1])
    return round(prob * 100.0, 1)
Enter fullscreen mode Exit fullscreen mode

3. 1-Click Self-Hosting Blueprint (render.yaml + Dockerfile)

For boutique agencies that want a private team instance, the repository includes a declarative render.yaml and Dockerfile to spin up the FastAPI + TabPFN microservice in one click.

Why Does Open Innovation Matter?

For a Side Hustle tool like FreelanceShield AI, open-source and open-weight AI isn't just a philosophical preference—it is the entire reason the product can legally and economically exist:

  1. Zero NDA & Contract Leakage (Privacy by Architecture): Freelancers and agencies are legally prohibited from uploading client contracts and unreleased product specs to proprietary third-party cloud models. Running open-weight Gemma 4 4B locally via Ollama + TabPFN on-device guarantees 0 bytes of client data ever leave the freelancer's machine.
  2. Unit Economics That Make a $19/mo Micro-SaaS Profitable: When users run contract audits locally on their own laptop GPU/CPU (or a tiny self-hosted container), the creator's marginal per-token API cost is $0.00. You never get wiped out by heavy power users auditing 500-page enterprise RFPs.
  3. No Vendor Lock-In or Sudden Deprecations: If a freelancer relies on a prompt-engineered workflow to price change orders, a silent closed-model update shouldn't break their billing pipeline. Pinning open-weight checkpoints (gemma4:4b + TabPFN) ensures deterministic, auditable results forever.

My Agent Session

While building FreelanceShield AI, I paired with an agentic coding assistant inside my workspace to rapidly iterate from problem discovery to a deployed dual-model architecture:

  • Step 1 — Identifying the High-ROI Niche: We rejected generic "chat with PDF" wrappers and focused on the highest-friction moment in freelancing: how to say "that's out of scope, here is the price" without sounding confrontational or violating an NDA.
  • Step 2 — Combining Text + Tabular Open Models: Instead of forcing an LLM to guess numerical invoice risk, we paired open-weight local text inference (for SOW clause matching and polite Change Order copywriting) with Prior Labs' TabPFN (for structured small-table late-payment probability estimation).
  • Step 3 — Zero-Friction Browser Experience: To make sure anyone reviewing or testing the tool can experience it immediately, we built a full 3-column interactive workbench in vanilla HTML5 Canvas + ES6 JavaScript that supports both instant browser simulation and live http://localhost:11434 Ollama connection.

My First User

I tested FreelanceShield AI with two fellow independent full-stack developers who do freelance Next.js and AI consulting on the side:

  • Real Feedback: "Usually when a startup founder DMs me on Slack asking for a 'quick dark-mode toggle or webhook' on Thursday night, I just eat the 8 hours because writing a formal change order feels awkward. Being able to paste the SOW and Slack message locally, see the exact clause citation, and copy a friendly counter-proposal with a 50% deposit recommendation in 10 seconds literally saved me $950 on an active sprint."
  • Iteration Made from User Feedback: Initially, the tool only flagged out-of-scope requests. My first tester pointed out that freelancers also need to reassure clients when a minor bug fix is legitimately in scope—so I added the ✅ In-Scope Verification path (Scenario 4) and the 1-Click Printable Change Order PDF (🖨️ Export Change Order PDF) button!

Prize Categories

  • Best Use of TabPFN (Prior Labs): Uses TabPFNClassifier as a zero-shot tabular risk engine over the freelancer's small historical invoice ledger (5–50 rows) to predict the probability of >14-day invoice payment delays and dynamically recommend upfront escrow/deposit percentages.
  • Best Use of Render: Includes a production-ready FastAPI microservice (agent_backend.py) and declarative render.yaml blueprint for 1-click private agency self-hosting.

Top comments (0)