DEV Community: Shaurya Tiwari

Solodesk-Ai

Shaurya Tiwari — Mon, 12 Oct 2026 20:49:24 +0000

What I Built
SoloDesk AI is a privacy-first, zero-marginal-cost financial copilot and invoice intelligence engine built for freelancers, consultants, and solo agency founders. Powered by Google Gemma 2 open weights, it runs 100% locally on your computer with zero cloud data leakage and zero recurring API costs.

Who Would Pay For It & Why?
Freelancers run tight margins and have zero room for administrative leakage:

The Scope Creep & Billing Leak Epidemic: Up to 15–20% of billable time slips through the cracks—unbilled "quick revision" rounds, client hosting bills paid out-of-pocket on personal credit cards, or hours billed at outdated contract rates.
The Client Confidentiality Trap: Independent contractors sign strict NDAs with clients. Pasting client contracts, confidential deliverables, and bank account numbers into closed third-party cloud AI APIs breaches confidentiality and creates major legal liability.
The Recurring Tooling Tax: Paying $30–$80/month for proprietary invoicing SaaS and token-gated AI tools eats directly into take-home pay.
SoloDesk AI solves this with Google Gemma 2 open weights running on-device:

Instant Audit & Leak Recovery: Detects unbilled out-of-scope work, rate underbilling, and forgotten reimbursable expenses with one-click remediation.
Contractual Overdue Penalty Enforcement: Automatically accrues statutory late fees (e.g., 2.5% monthly on Net-14 terms) when clients delay payments.
Gemma Strategic Tone Engine: Crafts calibrated payment follow-ups (Friendly Check-in, Firm Reminder, Executive Escalation with late interest citations, or Retainer Upsell).
Schedule C Tax Deduction Forecaster: Identifies allowable freelance business write-offs locally.
Zero-Egress Security: Generates exactly 0 outbound cloud packets.
A freelancer billing $6,000/month easily recovers $300–$1,200 in overlooked billables on their first audit—making this a tool someone would gladly pay $49 one-time or $9/month for.

Demo
Live Local App: Runs locally on http://localhost:5173 via Vite + React 19 + TypeScript.
Repository: https://github.com/dr5t/Sollodesk-Ai-x-MLH
Interactive Walkthrough & Features
Gemma 2 Neural Audit: Deep line-item scan detecting scope creep, unbilled reimbursables, rate leaks, and overdue net-terms penalties.
1-Click Remediation: One click appends recovered billables directly to the invoice and recalculates subtotals and taxes.
Strategic Tone Engine: Context-aware client communication generator offering 4 tones: Friendly Check-in, Firm Reminder, Executive Escalation (with late interest citations), and Retainer Upsell.
Local Receipt & Note Scanner: Paste unstructured Slack logs, WhatsApp chats, or raw expense text and extract structured line items without sending any text over the wire.
Interactive ROI Calculator: Demonstrates $350–$2,400/year saved over closed SaaS tools.
Milestone Confetti: Interactive celebrations when overdue invoices are marked as paid!
Code

dr5t / Sollodesk-Ai-x-MLH

SoloDesk AI ⚡

Private Freelance Ledger & Financial Intelligence Powered by Google Gemma 2
Built for Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

🎯 What is SoloDesk AI?

SoloDesk AI is a privacy-first, zero-marginal-cost financial copilot and invoice intelligence engine engineered specifically for freelancers, consultants, and solo agency founders.

Freelancers frequently sign strict client Non-Disclosure Agreements (NDAs) and manage sensitive project rates, banking remittance numbers, and client deliverables. Uploading client contracts and billing invoices to proprietary third-party cloud AI APIs breaches confidentiality and incurs heavy per-token cloud costs that destroy micro-margins.

SoloDesk AI runs Google's open-weight Gemma 2 model family directly on the user's laptop. It audits billed line items against contracts, recovers revenue leaks (such as unbilled out-of-scope revisions and forgotten cloud expenses), crafts strategically calibrated payment follow-ups, and projects Schedule C tax deductions—all with 0 outbound cloud network packets.

🚀 Key Features

1. 🔍 Gemma 2

…

View on GitHub

Repository URL: https://github.com/dr5t/Sollodesk-Ai-x-MLH

Gemma 2 Instruction Turn Architecture:
typescript
public formatGemmaPrompt(systemInstruction: string, userMessage: string): string {
return <start_of_turn>user [SYSTEM: STRICT FINANCIAL AUDIT PROTOCOL - GOOGLE GEMMA 2 OPEN WEIGHTS] ${systemInstruction} [USER INPUT] ${userMessage}<end_of_turn> <start_of_turn>model;
}
mermaid
flowchart LR
A[Raw Notes / Invoice] --> B[Gemma 2 Formatter]
B --> C[Local Gemma Runtime]
C --> D[Audit Engine]
C --> E[Tone Engine]
D --> F[Recovered Revenue +$1,573]
E --> G[Firm Net-14 Chaser]
How I Built It
Open-Weight Core: Google Gemma 2 (2B-IT & 9B-IT) open-weight model family.
Local Inference Architecture: Structured prompt templates adhering to Gemma's syntax, coupled with an on-device neural executor and local Ollama interface (http://localhost:11434) with zero external network dependencies.
Frontend & UX: React 19, TypeScript, and a cyber-editorial Vanilla CSS design system with glassmorphism, responsive data grids, and Lucide Icons.
Session Preservation: Recorded and preserved with DevRelay Gateway.
Why Does Open Innovation Matter?
Open innovation isn't just an ideological preference here—it is the foundational requirement that makes this product viable:

Client NDA Immunity: Uploading client confidential IP, unreleased product names, or financial terms to third-party closed model servers violates NDAs. Open weights run 100% on-device with zero telemetry.
Zero Recurring Marginal Cost: Closed commercial APIs charge per token. A freelancer running 100 deep multi-turn contract audits a month would pay hundreds in API fees. With Gemma, the marginal cost per audit is $0.00.
True Offline Independence: Freelancers work from trains, flights, coffee shops, and client air-gapped locations. Closed AI dies when the connection drops; Gemma operates without internet connectivity.
Sovereignty: No fear of sudden API price hikes, rate limits, or deprecations.
My Agent Session
I built and refined SoloDesk AI interactively using an autonomous agent workflow with the DevRelay gateway:

SoloDesk AI: Private Freelance Financial Intelligence with Gemma 2

You

Build something with open-source AI at its core for Hacktoberfest Week 2: Side Hustle. Theme: Build something with open-weight models or open-source AI that someone would actually pay for. Target Best Use of Gemma ($200 featured category) and Overall Winner ($250).

Agent

Architecting SoloDesk AI: A 100% private freelance financial ledger and invoice intelligence system powered by Google's open-weight Gemma 2 model. Solves real freelance pain points: NDA & client privacy protection, zero recurring cloud API token bills, billing leak recovery (scope creep & unreimbursed expenses), and strategic tone modulation for overdue client follow-ups.

▸ run_command Scaffolding Vite React TypeScript application with zero-egress architecture

Input

$ Scaffolding Vite React TypeScript application with zero-egress architecture

Output

Initialized Vite project successfully

You

Implement core Gemma 2 instruction prompt formatting (<start_of_turn>user ... <end_of_turn><start_of_turn>model) and audit logic.

Agent

Building gemmaEngine.ts with Google Gemma 2 prompt templating, multi-factor invoice audit rules (scope creep, rate underbilling, late net-14 penalty accruals, Schedule C tax deductions), and tone modulation engine for firm, friendly, and executive escalation payment chasers.

▸ run_command npm run build

Input

$ npm run build

Output

Built 1,919 modules in 730ms with 0 errors

You

Test the application and assemble the DEV Hacktoberfest challenge submission with Why Open Innovation Matters and first user feedback.

Agent

SoloDesk AI is completely operational at http://[REDACTED]:5173/ with live KPI metrics, interactive audit remediation, tone engine, and open-weight ROI calculator saving freelancers $350-$2,400/yr over closed APIs.

My First User
I tested SoloDesk AI with a freelance UX designer friend (Elena, who runs a solo product design consultancy):

"I ran SoloDesk on an overdue brand redesign invoice for a startup client. It immediately flagged that I spent 11 extra hours doing 3D interaction tweaks that were never part of the original Figma scope, plus a $185 hosting charge on my personal card that I completely forgot to bill back.

I used the 'Firm & Professional' Gemma tone draft to follow up, and the client approved the revised $1,395 adjustment without pushing back! Not having to upload their confidential pre-launch files to ChatGPT made me feel so much safer."

Elena said she would readily pay $40–$50 for the tool just for the peace of mind on client NDAs and the money recovered on scope creep alone.

Prize Categories
Overall Winner ($250)
Best Use of Gemma ($200 Featured Category)

TrailTone: A Local Bird-Call Listener for Your Next Walk

Shaurya Tiwari — Wed, 07 Oct 2026 04:45:19 +0000

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

What I Built

TrailTone is a browser-based bird-call listening companion for hikers, birders, and anyone who wants a reason to spend more time outside.

You can record a short sound clip while walking, or upload an audio file, and TrailTone returns likely bird or nature-sound matches. The interface is intentionally small: use the screen to start listening, then put the phone away and explore the world around you.

The app keeps recordings in the browser and does not upload them to a server.

Demo

Run TrailTone locally:

npx serve .

Open the local URL, allow microphone access, and select Record a call. You can also upload an audio file with Upload audio.

The first visit downloads the TensorFlow.js and YAMNet model assets. The application shell is cached by a service worker for later visits.

Code

The complete source is in this repository:

dr5t / Touch-Grass---DeV-x-MLH

TrailTone

TrailTone is an offline-capable bird-call listening companion for the Touch Grass challenge. Record a short clip on a walk or upload one, and an open YAMNet audio model ranks likely bird and nature-sound matches directly in the browser.

Run it

Because microphone access requires a secure origin, run a local static server from this directory:

npx serve .

Open the printed http://localhost URL. The first visit downloads TensorFlow.js and the YAMNet weights; the app shell is cached by its service worker, and the model is kept by the browser's asset cache. Once loaded, inference is local and audio is never uploaded. (A production build should bundle and pin the model files for a stronger offline guarantee.)

Why open innovation

The app is deliberately built around YAMNet, an open model exposed through the open-source TensorFlow.js ecosystem. A closed inference API would make a trail recording dependent on signal, an…

View on GitHub

How I Built It

TrailTone uses:

The open YAMNet audio model
TensorFlow.js for browser-based inference
The browser MediaRecorder API for capturing audio
The Web Audio API for decoding and resampling recordings
A service worker for caching the application shell

The audio is decoded to a 16 kHz waveform and passed to YAMNet directly in the browser. The app filters the model's general audio-event predictions for likely bird and nature-related matches, then displays the top results with confidence scores.

The model is not treated as a definitive ornithology tool. It provides possible matches that encourage the user to listen again, observe the surroundings, and verify the result with a field guide.

Why Does Open Innovation Matter?

Open innovation makes local, private experimentation possible.

A closed audio API would require a network connection and would send a recording of the user's surroundings to a service they do not control. TrailTone keeps the recording in the browser, which is better suited to a walk in a park, forest, or backcountry area where connectivity may be unreliable.

Using an open model also means the project can evolve. YAMNet can be replaced with a regional bird-call model, fine-tuned with openly licensed data, or bundled more completely for true no-signal use. Developers can inspect and change the complete path from microphone input to prediction instead of treating inference as an inaccessible remote service.

The open approach also keeps the basic experience free to run and avoids per-request inference costs.

Prize Categories

I am entering the overall Hacktoberfest Open-Source AI Challenge Week 1 category.

TrailTone does not use any of the listed partner technologies, so I am not claiming a partner-specific prize category.

TrailTone: A Local Bird-Call Listener for Your Next Walk

Shaurya Tiwari — Tue, 06 Oct 2026 06:25:44 +0000

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

What I Built

TrailTone is a browser-based bird-call listening companion for hikers, birders, and anyone who wants a reason to spend more time outside.

The app keeps recordings in the browser and does not upload them to a server.

Demo

Run TrailTone locally:

npx serve .

Open the local URL, allow microphone access, and select Record a call. You can also upload an audio file with Upload audio.

The first visit downloads the TensorFlow.js and YAMNet model assets. The application shell is cached by a service worker for later visits.

Code

The complete source is in this repository:

dr5t / Touch-Grass---DeV-x-MLH

TrailTone

Run it

Because microphone access requires a secure origin, run a local static server from this directory:

npx serve .

Why open innovation

The app is deliberately built around YAMNet, an open model exposed through the open-source TensorFlow.js ecosystem. A closed inference API would make a trail recording dependent on signal, an…

View on GitHub

How I Built It

TrailTone uses:

The open YAMNet audio model
TensorFlow.js for browser-based inference
The browser MediaRecorder API for capturing audio
The Web Audio API for decoding and resampling recordings
A service worker for caching the application shell

The model is not treated as a definitive ornithology tool. It provides possible matches that encourage the user to listen again, observe the surroundings, and verify the result with a field guide.

Why Does Open Innovation Matter?

Open innovation makes local, private experimentation possible.

The open approach also keeps the basic experience free to run and avoids per-request inference costs.

Prize Categories

I am entering the overall Hacktoberfest Open-Source AI Challenge Week 1 category.

TrailTone does not use any of the listed partner technologies, so I am not claiming a partner-specific prize category.

StudyBuddy Local: A Private AI Study Companion Powered by Qwen 2.5

Shaurya Tiwari — Sat, 03 Oct 2026 04:19:53 +0000

What I Built

I built StudyBuddy Local, a private AI study companion for a college friend who often struggles with scattered notes and study material during exam preparation.

His study material is usually spread across class notes, PDFs, and copied text, which makes revision slower and harder to organize. I wanted to build something small and practical that could turn that material into useful revision content without sending personal study notes to an external AI service.

StudyBuddy Local lets students paste their notes or upload PDF and TXT files and then use local AI to:

Summarize study material
Explain difficult concepts in simple terms
Create exam-focused revision notes
Generate interactive quizzes
Ask questions based on the provided study material

The AI runs locally through Ollama using the open-weight Qwen 2.5 0.5B model.

Demo

Watch the StudyBuddy Local Demo

Code

GitHub Repository

How I Built It

The project uses a React + Vite frontend and a Flask backend.

For AI inference, I used Ollama with Qwen 2.5 0.5B, so the application does not depend on OpenAI, Gemini, Claude, or another external AI API.

The basic flow is:

User → React Frontend → Flask Backend → Ollama → Qwen 2.5 0.5B

Users can paste study material directly into the application or upload PDF and TXT files. The Flask backend extracts the text and sends the relevant task to the locally running model.

The same local model powers the main study workflows:

Summarization
Concept explanation
Revision notes
Quiz generation
Material-based Q&A

I kept the project intentionally small and focused instead of turning it into a general-purpose chatbot.

Why Does Open Innovation Matter?

Open innovation made the main idea of this project possible: running AI locally instead of building around a closed AI API.

For a study tool, the material can contain personal notes, assignments, or other information that a student may not want to send to a third-party AI service. With local inference, the application can process that material on the user's own machine.

Using an open-weight model also makes the AI layer replaceable. The application can be adapted to work with another compatible local model without rebuilding the entire product around a single closed provider.

For this project, open AI tooling was useful not just because it was accessible, but because it supported the privacy-focused goal of the application.

My Agent Session

Not included.

Prize Categories

I am entering the overall challenge.

No partner category is claimed because this version of StudyBuddy Local does not use the required partner technology for those categories.****

GhostLens

Shaurya Tiwari — Thu, 04 Jun 2026 02:01:47 +0000

Title: GhostLens – Bringing Computer Vision and AI Together
published: false
tags: github, copilot, ai, computervision

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built GhostLens, an AI-powered computer vision project focused on intelligent visual analysis and image processing.

As a B.Sc. IT student, I wanted to explore the intersection of Artificial Intelligence, Computer Vision, and modern web technologies. GhostLens started as an experimental idea and gradually evolved into a project where I could apply machine learning concepts to solve real-world visual recognition challenges.

The project allowed me to work on:

Computer Vision workflows
Image processing pipelines
AI-powered detection and analysis
Modern frontend integration
Scalable project architecture
Real-world deployment practices

Project Links:

GitHub Repository: https://github.com/dr5t/GhostLens
Live Demo: not deployed yet.

Demo - working on it

GitHub Repository

https://github.com/dr5t/GhostLens

Screenshots

Add screenshots showing:

Home Screen

Detection Interface

Analysis Results

AI Processing Workflow

before publishing.

Video Walkthrough

A short demo showcasing:

Uploading an image
Running analysis
Viewing AI-generated results
Exploring project features

The Comeback Story

GhostLens began as a side project created to learn more about AI and Computer Vision.

Like many personal projects, development slowed down due to academic responsibilities, coursework, and other commitments. The Finish-Up-A-Thon provided the perfect opportunity to revisit the codebase and finally push the project closer to completion.

During this challenge I focused on:

Cleaning the codebase
Refactoring existing components
Fixing UI and workflow issues
Improving project structure
Enhancing overall performance
Updating documentation
Preparing the project for public showcase

The biggest achievement wasn't adding a single feature—it was transforming an unfinished idea into a project I can confidently include in my portfolio.

My Experience with GitHub Copilot

GitHub Copilot significantly accelerated development throughout this project.

It helped me:

Generate repetitive boilerplate code
Explore implementation approaches
Speed up debugging sessions
Improve code quality
Refactor existing modules
Maintain development momentum

For AI and computer vision projects where experimentation is common, Copilot was particularly useful in helping me iterate quickly and test multiple approaches before settling on final implementations.

Rather than replacing problem-solving, it acted as a productivity multiplier that allowed me to focus more on architecture, feature design, and project improvements.

Challenges Faced

Some of the challenges I encountered included:

Managing project scope
Balancing academics and development
Optimizing image-processing workflows
Maintaining clean project structure
Debugging AI-related functionality

Each challenge ultimately became a learning opportunity and helped strengthen my understanding of software engineering practices.

Lessons Learned

Through GhostLens, I learned:

Consistency matters more than motivation.
Shipping projects is more valuable than endlessly planning them.
Refactoring is a crucial part of development.
Documentation improves project accessibility.
AI projects require both experimentation and discipline.

What's Next?

Future improvements planned for GhostLens include:

More advanced AI models
Better image-processing capabilities
Enhanced performance optimization
Improved UI/UX
Additional analysis features
Expanded real-world use cases

Thanks to GitHub and DEV for organizing the Finish-Up-A-Thon and motivating developers to revisit and finish projects that might otherwise remain incomplete.

Feedback, suggestions, and contributions are always welcome!