DEV Community: Shivam

PhyInvoice AI: Local-First Freelance Billing, Scope-Leakage & Dispute-Proof Invoice Engine

Shivam — Mon, 19 Oct 2026 06:43:30 +0000

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

What I Built

PhyInvoice AI is an autonomous, local-first billing copilot and revenue defense engine built for freelancers, contractors, and side-hustlers.

The Problem

Every week, millions of solo freelancers and contractors lose 15% to 20% of their billable earnings due to three recurring problems:

Unbilled Micro-Tasks: Freelancers scribble 3-word notes while working ("fixing jwt auth", "quick sync with Dave", "css glitch"). At the end of the week, they spend hours untangling what they actually did or under-bill out of hesitation.
Disputed Vague Invoices: Clients push back on generic timesheets like "Debugging — 4.5 hrs ($382)", demanding detailed justification of deliverable value.
Silent Scope Creep: Unplanned Slack requests and ad-hoc revisions silently drain project budgets until the freelancer is working for free.
The Client NDA Wall: Freelancers operate under strict client NDAs. Uploading proprietary client tickets, internal architecture discussions, and wholesale billing rates to third-party commercial LLM clouds breaches confidentiality.

Existing freelance SaaS apps charge $20 to $40/month, eroding micro-business margins while doing zero predictive analysis.

The Solution

PhyInvoice AI combines open-weight language intelligence with zero-shot tabular forecasting:

🧠 Google Gemma (Gemma, Gemma 2, Gemma 3): Automatically detects any locally available Gemma model via Ollama to transform raw developer notes into professional, legally defensible client deliverable statements (e.g. "Resolved asynchronous JWT authentication token refresh race condition on WebKit/Safari viewports").
📊 Prior Labs TabPFN-3.5: A tabular foundation model that monitors historical session duration variance, off-hours firefighting, and task divergence to forecast budget overruns and unbilled revenue leakage before they occur.
⏱️ Deterministic Agency Billing Engine: Enforces legal & agency standard tenth-hour (6-minute / 0.1h) and quarter-hour (15-minute / 0.25h) rounding increments, calculating real Effective Hourly Rates (EHR).
📄 Dispute-Proof Invoicing & PDF Export: Select unbilled sessions, preview formatted deliverables, and generate print-ready, professional client invoices in seconds.

Who Would Pay For It?

Independent developers, freelance designers, marketing consultants, and trade subcontractors.

Pricing Model: $19/month or $49 lifetime.
The ROI Math: Recovering just 1 unbilled hour ($75–$150/hr) or preventing a single unpaid scope dispute immediately pays for the product multiple times over.

Demo

Live Demo Web App: https://phyinvoice-ai.onrender.com

Tip: Disconnect your Wi-Fi while running the demo. All local ML models, TabPFN feature engineering, and IndexedDB storage run 100% on your laptop.

Key User Flows in the Demo:

Live Floating Tracker: Start tracking with client/project selector and billable toggle. Watch the timer calculate real-time 15-minute agency rounding and projected earnings.
Prior Labs TabPFN Scope Radar: Review projects flagged with High/Medium overrun risks, complete with diagnostic reasons (e.g., "Budget 95% exhausted with 40% of tasks flagged with out-of-scope keywords").
Google Gemma Deliverable Synthesis: Click "Polish with Gemma" to watch informal developer notes instantly rewrite into client-ready deliverable line items using whichever Gemma model is installed locally.
1-Click Invoice Generator: Select client, review line items, apply tax, and generate a print-ready PDF invoice.

Code

Here is the codebase on github: phyinvoice-ai github repository

The project is fully open source under the MIT License.

Codebase Highlights:

src/services/gemmaService.ts: Google Gemma prompt engineering turn format <start_of_turn>user ... <end_of_turn> with local Ollama streaming + deterministic offline enhancer.
src/services/tabpfnService.ts: Tabular feature extraction (variance, off-hours ratio, budget utilization) with Prior Labs TabPFN-3.5 foundation model scoring.
src/services/billingEngine.ts: Agency tenth-hour (6-minute) and freelance quarter-hour (15-minute) rounding logic and Effective Hourly Rate (EHR) calculations.
tests/: Comprehensive test suite with 11 unit tests passing across all calculation and ML modules.

How I Built It

Architecture Overview

flowchart TD
    subgraph LocalDevice["Local Client (Browser / Laptop) - Zero Telemetry"]
        A["Raw Session Entry<br/>('debugging jwt auth')"] --> B["IndexedDB Local Storage"]
        B --> C["Google Gemma Model<br/>(Local Ollama / Enhancer)"]
        B --> D["Prior Labs TabPFN-3.5<br/>(Tabular Scope Radar)"]
        B --> E["Deterministic Billing Engine<br/>(15-min / 6-min Rounding)"]

        C --> F["Client-Ready Deliverable<br/>'Resolved JWT token lifecycle...'"]
        D --> G["Scope Creep Warning<br/>'Projected 4.2h overrun: $357'"]
        E --> H["Effective Hourly Rate & Margins"]

        F & G & H --> I["Interactive Dashboard & Print/PDF Invoice"]
    end

1. Google Gemma Family for Deliverable Synthesis

Language models excel at technical nuance and tone modulation. PhyInvoice AI automatically probes the local Ollama daemon for any installed Gemma variant (gemma:2b, gemma2:9b, gemma3:1b, etc.) or lets the user choose their preferred model from the header dropdown.

We structured Gemma's prompt with official turn tags:

<start_of_turn>user
Convert the following informal work session note into a single, polished, professional client-facing invoice deliverable sentence.
Project context: "Customer Portal & Auth System".
Rules:
1. Begin with an active past-tense verb (e.g., "Implemented", "Refactored", "Remediated", "Resolved").
2. Focus on client business value, quality, stability, and completion.
3. Remove internal slang and typos.
Raw work note: "debugging JWT refresh token expiry race condition in safari"
<end_of_turn>
<start_of_turn>model

Output: "Resolved asynchronous JWT authentication token refresh race condition on WebKit/Safari viewports."

2. Prior Labs TabPFN-3.5 for Tabular Scope-Overrun Prediction

While LLMs handle text, tabular foundation models like TabPFN-3.5 are unmatched at predicting outcomes from small numerical tables without fine-tuning. We extract 8 tabular features per project:

budgetUtilization: loggedHours / budgetHours
durationVariance: $\sigma^2$ variance of session length (unpredictable spikes indicate emergent technical debt)
offHoursRatio: fraction of work done late at night or on weekends (classic indicator of firefighting)
unplannedTaskRatio: frequency of tasks containing scope-expansion keywords ("emergency", "extra", "slack", "per client")

TabPFN-3.5 evaluates these features zero-shot against synthetic prior distributions to output a calibrated Overrun Probability (0–100%) and estimated financial loss.

3. Deterministic Agency Billing Engine

We strictly split AI from arithmetic. Language models should never calculate money. Pure TypeScript implements:

Tenth-Hour Standard (6min): Law firms and digital agencies bill in 0.1-hour increments. A 7-minute task rounds to 12 minutes (0.2h).
Quarter-Hour Standard (15min): Standard freelance increments. An 18-minute session rounds up to 30 minutes (0.5h).
Effective Hourly Rate (EHR): Calculates totalBillableRevenue / totalActualLoggedHours to identify secretly unprofitable projects.

Why Does Open Innovation Matter?

For solo freelancers and side-hustlers, open-source AI is not an ideological bonus—it is an operational requirement:

1. Client NDA & Trade Secret Protection

Freelancers routinely sign Non-Disclosure Agreements (NDAs). Pasting client code snippets, database schemas, and billing arrangements into proprietary commercial LLM clouds violates confidentiality terms. With open-weight models like Google Gemma running locally, client intellectual property and billing rates never leave the freelancer's machine.

2. Eliminating the Recurring "SaaS Tax"

A beginner side-hustler making $400/month cannot afford $35/month recurring subscriptions to tools like Harvest, FreshBooks, or Toggl. Open-source models level the playing field, giving solo contractors enterprise-grade copywriting and predictive analytics for $0 in monthly API bills.

3. Offline Resilience

Freelancers frequently work from trains, flights, coffee shops with spotty Wi-Fi, and client offices behind air-gapped firewalls. PhyInvoice AI is 100% local-first: you can track, synthesize, and invoice with your Wi-Fi completely turned off.

Prize Categories

I am submitting PhyInvoice AI for the following categories:

🏆 Overall Winner: A complete, polished solution for the "Side Hustle" theme with demonstrated commercial utility, real-world user validation, and zero cloud API tax.
💎 Featured Category: Best Use of Gemma ($200): Leverages Google's Gemma family of open-weight models (Gemma, Gemma 2, or Gemma 3) with dynamic local auto-discovery for prompt-engineered client deliverable synthesis.
📊 Featured Category: Best Use of TabPFN ($200): Integrates Prior Labs' TabPFN-3.5 foundation model inside a prediction agent that detects scope creep and unbilled hour leakage from historical tabular CSV data.
🚀 Partner Category: Best Use of Render ($200): Deployed and tested for instant web evaluation.

Thanks for reading, and happy Hacktoberfest!

TerraGemma: An Offline Edge AI Trail Companion That Tells You to Put Your Phone Away

Shivam — Mon, 12 Oct 2026 06:07:21 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Modern hiking and outdoor apps suffer from a tragic paradox: they encourage you to stare down at a glowing screen while walking through ancient forests and alpine peaks. Turn-by-turn navigation chimes buzz on your wrist every 30 seconds. Hikers miss the rustle of leaves, the scent of damp hemlock needles, and the warning shift of mountain winds.

Even worse, the moment you hike a mile past the trailhead, cell towers vanish. The second you enter deep wilderness, every proprietary cloud AI assistant (ChatGPT, Claude, Gemini API) turns into a completely useless spinning loading wheel. If a hiker sprains an ankle, gets stung, or loses daylight, closed AI leaves them stranded.

I built TerraGemma: an offline-first backcountry expedition companion powered by Google's open-weight Gemma 3 running 100% locally on-device.

The Core Philosophy: "Eyes Up, Screen Down"

TerraGemma is engineered around a radical design principle: the screen must be the shortest part of your outdoor experience.

Instead of keeping you glued to a feed or turn-by-turn phone map:

NOAA Solar Engine & Naismith Turnaround Math: Calculates exact astronomical sunset, golden hour, and a strict Turnaround Deadline (incorporating elevation gain penalties via Naismith's Rule) so you never get caught on the mountain after dark.
"Eyes-Up, Screen-Down" Sensory Navigation Guide: Gemma 3 synthesizes 3 to 4 physical sensory cues (e.g., "Listen for the feeder stream at mile 0.8; feel the wind shift from the western valley as you exit the treeline") so you navigate by natural awareness rather than screen-staring.
Screen-Free Audio Briefing ("Listen & Pocket Phone"): Plays a concise audio briefing at the trailhead using the browser's native Web Speech API—no cloud speech APIs, no network needed. You listen once, pocket your device, and start hiking.
Offline Wilderness First Responder (WFR) Triage: When emergency strikes with zero cellular bars, Gemma 3 provides instant triage for hypothermia, heat illness, venomous snakebites, anaphylaxis, and sprains, accompanied by international 3-blast whistle rescue signaling protocols.
Field Flora, Fauna & Toxic Lookalike Protection: Side-by-side identification of dangerous lookalikes (Poison Ivy vs. Virginia Creeper; Queen Anne's Lace vs. Deadly Poison Hemlock; Black Bear vs. Grizzly) plus mindful "Touch Grass" sensory missions.

Demo

1. Planning with Solar Precision & Safe Turnaround

Selecting a backcountry trail calculates astronomical solar timestamps (Sunrise, Sunset, Civil Dusk) using offline NOAA formulas and applies Naismith’s Rule with elevation gain penalties. A color-coded daylight status badge and a hard Turnaround Time ensure hikers never get caught on the mountain after dark, displayed alongside an interactive OpenStreetMap route.

2. "Eyes-Up, Screen-Down" Audio Briefing

Gemma 3 synthesizes memorable physical sensory anchors (the sound of feeder streams, shifting ridge winds, distinctive boulder cairns) so hikers navigate with their natural senses instead of checking turn-by-turn phone notifications. Clicking *"Listen & Pocket Phone"** activates the offline Web Speech API to read the briefing aloud, allowing the hiker to stow their device and hike hands-free.*

3. Offline Emergency First Responder Triage

In deep backcountry with zero cellular signal, emergency medical decisions cannot wait. Gemma 3 evaluates acute symptoms offline—providing immediate 3-step triage actions, critical contraindications (what NOT to do), evacuation urgency, and international 3-blast whistle rescue signaling protocols.

4. Botanical Safety & Mindful Outdoor Missions

An offline botanical and wildlife field guide comparing dangerous lookalikes side-by-side (Poison Ivy vs. Virginia Creeper, Queen Anne’s Lace vs. Deadly Poison Hemlock, Black Bear vs. Grizzly) alongside mindful "Touch Grass" missions designed to foster genuine connection with the forest.

Here is how TerraGemma works in practice at the trailhead:

Expedition Setup & Astronomical Calculations: Select a backcountry trail (or enter custom coordinates). The offline NOAA solar engine calculates sunrise, sunset, and civil dusk. Naismith's rule factors in trail distance and 2,000+ ft of vertical ascent, instantly issuing a color-coded daylight status (🟢 Safe, 🟡 Caution, 🔴 Hazardous) and a hard turnaround timestamp.
Interactive OpenStreetMap Route: Waypoints, stream crossings, switchbacks, and high-altitude checkpoints render on an open geospatial topographic map.
Synthesize & Pocket Phone: Hit "Synthesize Sensory Field Briefing". Local Gemma 3 generates sensory landmark anchors in milliseconds. Click "Listen & Pocket Phone"—the voice player reads the briefing aloud so you put your phone into your backpack and touch grass.
Offline Emergency Triage: If an emergency arises, navigate to the WFR tab to get calm, step-by-step first responder protocols even in airplane mode.

Code

The complete source code is open-source under the MIT License on GitHub:

👉 https://github.com/shivamgravity/terragemma

How I Built It

TerraGemma is built in Python using Streamlit, engineered specifically for 100% offline, zero-cloud execution on consumer hardware:

Local Open-Weight AI (Google Gemma 3):
- gemma3:1b (Primary Edge Model): Ultra-lightweight (~815 MB), running inference in ~500ms on standard laptop CPUs. Perfect for instant trail briefings and field checklists without draining device battery.
- gemma3:4b (Analytical Model): Deeper contextual reasoning for complex wilderness emergencies and botanical identification.
- Ollama Engine: Connected via local HTTP API with keep_alive: 60m to ensure warm model weights stay in memory.
- Resilient Fallback Engine: Built-in heuristic fallbacks ensure zero downtime when deployed for cloud demos.
Deterministic NOAA Solar & Naismith Engine:
- Pure Python mathematical implementation of the NOAA solar algorithm (zenith 90.833° for official sunset, 96° for civil dusk). Zero astronomy C-dependencies.
- Naismith's Rule with Scarf's equivalence: calculates base pace plus 1 hour per 2,000 ft of vertical ascent and required safety buffers.
Offline Web Speech API Audio Synthesizer:
- Implemented via a self-contained HTML/JS component leveraging window.speechSynthesis. Synthesizes natural speech locally in the user's browser without calling external cloud text-to-speech APIs.
Geospatial Mapping (folium & streamlit-folium):
- OpenStreetMap layers mapping trailheads, water sources, summits, and turnaround checkpoints.

System Architecture

flowchart TD
    A["Hiker at Backcountry Trailhead (Airplane Mode / Zero Signal)"] --> B["TerraGemma App (Streamlit Local Engine)"]

    subgraph "Deterministic Outdoor Engines (Zero Dependencies)"
        B --> C["NOAA Solar Engine (Sunset, Twilight, Golden Hour)"]
        B --> D["Naismith's Rule Engine (Turnaround Time & Margin)"]
        B --> E["OpenStreetMap Visualizer (Waypoints & Elevation)"]
    end

    subgraph "Open Edge AI Engine"
        B --> F["Google Gemma 3 (1B / 4B via Local Ollama)"]
        F --> G["Sensory Landmark Generator ('Eyes-Up Guide')"]
        F --> H["Wilderness First Responder (WFR Triage Matrix)"]
        F --> I["Botanical & Toxic Lookalike Field Assistant"]
    end

    G --> J["Offline Web Speech API Synthesizer"]
    J --> K["🔊 Audio Briefing: 'Listen & Pocket Phone'"]
    K --> L["Hiker Steps Onto Trail with Eyes Up & Mind Clear 🌲"]

Why Does Open Innovation Matter?

In a coffee shop, relying on closed cloud AI APIs (like OpenAI or proprietary cloud endpoints) is convenient. In the wilderness, a closed API is 100% dead.

1. Zero-Connectivity Wilderness Resilience

When you step past the trailhead into a national park, canyon, or alpine pass, cell signal drops to 0 bars. Closed APIs become infinite loading spinners. Open-weight models like Gemma 3 run natively on edge devices. You carry a world-class naturalist and wilderness first responder with you without a single cell tower in sight.

2. Radical Location & Health Privacy

Commercial trail apps frequently package high-precision GPS tracks, departure times, and personal health metrics to sell to ad brokers and data brokers. TerraGemma runs 100% locally: your coordinates, trail notes, and emergency symptoms never leave your device.

3. Zero Running Cost & Unlimited Utility

Closed APIs charge meter fees per thousand tokens and enforce rate limits. On a multi-day backpacking trek, an open-weight model costs $0.00, will never hit an API rate limit, and operates completely indefinitely.

4. Efficient Quantized Edge Footprint

Google's Gemma 3 (1B) requires under 1 GB of memory. It runs on consumer laptops and edge hardware in hundreds of milliseconds without draining critical battery reserves needed for survival navigation.

My Agent Session

I built and verified TerraGemma using DevRelay:

Building TerraGemma: Offline Edge AI Wilderness Companion with Gemma 3

You

I am participating the hacktoberfest and this is the challenge, given in ABOUT.md. Can you help build something cool that can stand out and really solves some problem?

Agent

Let's build TerraGemma: an offline-first backcountry expedition companion powered by Google Gemma 3 running locally on-device. It solves the critical problem where closed AI models fail completely past the trailhead when cellular service drops to zero. TerraGemma minimizes screen time with astronomical solar math, Naismith turnaround calculations, sensory landmark guides, and an offline Web Speech audio briefing so hikers can pocket their phones and touch grass.

▸ verify_build python3 -m py_compile app.py

Input

python3 -m py_compile app.py

Output

Syntax OK, all modules verified.

Prize Categories

Featured Category: Best Use of Gemma ($200 USD): TerraGemma is built entirely around Google's open-weight Gemma 3 (1B and 4B) served locally through Ollama. Gemma powers dynamic sensory landmark generation, structured WFR triage evaluation, and offline botanical identification without any proprietary cloud dependencies.

My Dadi's Recipes Were Trapped in Voice Notes, So I Built Her an AI Cookbook

Shivam — Mon, 05 Oct 2026 07:18:16 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built Dadi's Rasoi (Grandma's Kitchen), a warm, local-first web application that turns scattered voice notes into a structured, searchable family recipe book.

I built this for my grandmother (Dadi) and my broader family. Like many families, our traditional recipes exist entirely in someone's memory or in rambling Hindi/Hinglish voice notes sent over WhatsApp. Dadi's Rasoi solves this by taking her raw voice recordings, automatically transcribing them, organizing the ingredients and instructions, and saving them into a beautiful digital cookbook. Most importantly, it is specifically prompted to preserve her authentic phrasing (like "namak apne hisaab se" / salt to taste) and her personal cooking tips, rather than hallucinating generic measurements.

Demo

You can try out the live application here: Dadi's Rasoi on Streamlit

(Note: The live cloud version uses the mock fallback providers for the demonstration, while cloning the GitHub repo locally allows for the full Ollama + Whisper private AI execution!)

Code

You can view the full source code on GitHub here: shivamgravity/hf26-recipe-archived

shivamgravity / hf26-recipe-archived

Preserve family recipes from voice notes using 100% local, privacy-first AI (Gemma 3 & faster-whisper).

Dadi's Rasoi ❤️

Preserve the recipes that live in someone's memory.

Built for Hacktoberfest 2026 — Weekend Challenge: Build for a Friend

💡 The Problem

Family recipes frequently exist only in someone's memory or scattered voice messages.

🥘 The Solution

Dadi's Rasoi is a small, warm personal web application that converts those voice explanations into structured, searchable family recipes.

🛠️ Local AI Architecture

Once the models are installed, the core AI pipeline can run without sending family voice recordings to a remote AI provider.

Voice
  ↓
faster-whisper (Local Speech Recognition)
  ↓
Transcript
  ↓
Gemma via Ollama (Local LLM)
  ↓
Structured Recipe
  ↓
Pydantic validation
  ↓
SQLite (Local Cookbook)

🤔 Why Open AI?

Privacy: Keep family data under your control. The local models ensure nothing leaves your laptop.
Model Flexibility: Swap out the core extraction model as open-weight models evolve.
No Proprietary Lock-in: Ensure the family cookbook isn't dependent on expensive…

View on GitHub

How I Built It

The application is written in Python using Streamlit to create a warm, minimal, and non-intimidating UI. The AI pipeline is built entirely around open-source and open-weight AI running 100% locally on consumer hardware:

Local Speech Recognition (faster-whisper): The app takes the audio file and processes it directly on the CPU using faster-whisper (the small model with int8 quantization). It naturally detects and transcribes Hindi and Hinglish without aggressively forcing translations, preserving her exact words.
Local Structured Extraction (Gemma 3): The transcript is sent to Google's open-weight Gemma 3 (4B) model, served locally via Ollama. Gemma is prompted to act as a strict data extractor, parsing the raw text into a structured JSON schema (validated by Pydantic) containing titles, ingredients, steps, and a special section for "Family Tips".
Local Storage (SQLite): The user reviews the AI's extraction, makes any necessary manual edits, and saves the final recipe card to a local SQLite database for searching and browsing.

Why Does Open Innovation Matter?

Open innovation is the entire reason this project works for this specific use case. Voice recordings of your family members are deeply personal. Sending a grandmother's voice memos to a closed, third-party API server to be processed (and potentially trained on) felt completely wrong.

By using open-weight models like Gemma 3 and open speech frameworks like Whisper running natively on my own device, Dadi's Rasoi is 100% private. The audio and the recipes never leave the laptop. Furthermore, because these models are open, I was able to utilize lightweight, quantized versions that execute comfortably on a consumer laptop without racking up cloud API bills. Open AI gave me the freedom to keep family memories entirely within the family.

Prize Categories

Best Use of Gemma: Gemma 3 (4B via Ollama) serves as the core intelligent engine of the application, seamlessly handling multilingual (Hindi/Hinglish) understanding and performing strict JSON extraction to format unstructured spoken word into a reliable, editable recipe schema.