DEV Community: Sneha Ghosh

Steady: Turn big goals into small steps with local open-source AI

Sneha Ghosh — Tue, 20 Oct 2026 18:11:38 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Steady: Small Steps, Real Progress.

Steady is a local-first AI planning assistant that turns overwhelming goals into small, actionable steps. Users enter a goal and their constraints, and Steady generates a practical plan using an open-weight AI model running locally.

It helps students, developers, and anyone struggling to get started spend less time planning and more time taking action.

Demo

Live Demo: To be added.

Run Steady locally by following the setup instructions in the repository.

Code

GitHub Repository: Steady | Hacktoberfest Week 3

How I Built It

I built Steady using Python, Flask, HTML, CSS, and JavaScript, with Ollama serving the AI model locally.

The default model is gemma3:1b. The application accepts a user's goal and optional context, validates the input, sends it to the local model, and returns an actionable plan.

The MVP includes a responsive interface, input validation, error handling, a copy-plan feature, and basic automated tests.

Why Does Open Innovation Matter?

I wanted to explore how AI-powered planning could work without depending on a closed, hosted AI API.

By running an open-weight model locally, Steady gives users greater control over their data and the freedom to experiment with different models. It can also avoid per-request hosted AI API fees, although local hardware and setup requirements still apply.

Open innovation makes it easier to inspect, adapt, and improve the tools we use.

My Agent Session

Not available yet. I plan to share a DevRelay session once the development workflow has been recorded.

The Lazy Payoff

Steady aims to reduce the friction between having a goal and knowing what to do next. Instead of starting with a blank page, users get a structured plan they can review, copy, and adapt.

The next step is to test it with real users and measure how much planning time it actually saves.

Prize Categories

No partner prize category claimed at this stage. I will update this section if the finished implementation meets the requirements of an eligible category.

Local Invoice & Receipt Sorter

Sneha Ghosh — Tue, 13 Oct 2026 17:26:41 +0000

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

What I Built

I built Local Invoice & Receipt Sorter, a privacy-first bookkeeping tool for freelancers, creators, and small side-hustle businesses.

Managing receipts and invoices manually is time-consuming and error-prone. This tool allows users to upload multiple invoice or receipt files and automatically extracts useful bookkeeping information, including:

Vendor name
Total amount
Date
Tax amount
Expense category
Source filename

The application also detects potential duplicate expenses, summarizes spending by category, and exports the processed data as a bookkeeping-ready CSV file.

The main users are freelancers, independent contractors, and small business owners who want a lightweight alternative to expensive accounting software while keeping their financial documents private.

Demo

The project currently runs locally as a Flask web application.

To run it:

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt
python app.py

Then open:
Text

http://localhost:5000

Code

The complete source code is available on GitHub:

https://github.com/SnehaghoshBarsha444/hf26_-Side_Hustle-DevChallange-
How I Built It

The application is built with Python and Flask.

The document-processing pipeline uses open-source tools, including:

Tesseract OCR through pytesseract for extracting text from invoice and receipt images
Pillow for image processing
pypdf for extracting text from PDF files
Python-based parsing and classification for identifying vendors, dates, totals, taxes, and expense categories
Flask and HTML/CSS for the web interface
CSV generation for exporting bookkeeping data

Users upload one or more files through the browser. The application processes each document locally, extracts the relevant fields, identifies possible duplicates, groups expenses by category, and presents the results in a simple dashboard.

No financial documents need to be sent to a remote server or third-party API.
Why Does Open Innovation Matter?

Open innovation made it possible to build this project using accessible, transparent, and locally runnable tools instead of relying on expensive proprietary accounting APIs.

Using open-source OCR and document-processing libraries provides several advantages:

Financial documents remain on the user's machine
Users are not locked into a cloud provider
The project can run with low infrastructure costs
Developers can inspect, improve, and customize the extraction logic
The tool can be adapted for different invoice formats, languages, and bookkeeping workflows

For a side-hustle product, local-first open-source technology makes it possible to create a useful and affordable tool while respecting user privacy.
My Agent Session

My First User

Prize Categories

Open-Source AI
Productivity
Small Business / Side Hustle
Privacy-first Technology

Important: Your current implementation uses open-source OCR and rule-based document extraction, but I did not find a generative AI or local language model in the repository. To keep the submission accurate, describe it as an open-source OCR and document-processing project unless you add an actual open-weight AI model.

Suryakavacham — Multimodal Media Integrity & Forensic Verification Shield

Sneha Ghosh — Thu, 08 Oct 2026 16:08:28 +0000

This is a submission for the MLH x DEV Writing Challenge

What I Built

For this project, I built Suryakavacham — Multimodal Media Integrity & Forensic Verification Shield, a cybersecurity and media-forensics platform designed to help investigators analyse the authenticity and integrity of images, videos, and audio files.

The idea behind Suryakavacham came from a growing problem: manipulated media and deepfakes are becoming increasingly difficult to identify. A single “fake” or “real” prediction is often not enough, especially in situations where the evidence may have serious consequences.

Instead of relying on a black-box deepfake score, Suryakavacham follows an “Evidence Before Verdict” approach. It combines multiple independent forensic signals, including:

Visual anomalies
Audio and spectral inconsistencies
Temporal irregularities
Audio-video synchronization
Metadata analysis
Provenance verification
Cross-modal consistency
Cryptographic file hashing

The platform presents the result as an explainable forensic assessment rather than an absolute truth. It shows the evidence behind an assessment, the confidence level, uncertainty, contradictory signals, and recommended next steps for human reviewers.

The application includes:

A cybersecurity-focused dashboard
Investigation and case management
Secure media ingestion
Media Vault
Visual, audio, and temporal analysis interfaces
Evidence Explorer
Forensic Timeline
Evidence Fusion
AI Forensic Reasoning
Mitigation Center
Forensic report generation
Model Registry
System Architecture visualization
Audit trail and review workflows

Suryakavacham also includes a deterministic demonstration mode with controlled cases for synthetic video indicators, synthetic audio indicators, and cross-modal inconsistencies. Demo results are clearly labelled as CONTROLLED DEMONSTRATION so that they are not confused with real scientific measurements.

The most important lesson I learned while building this project was that AI systems used for sensitive investigations must be transparent, uncertainty-aware, and designed with human review in mind. An AI assessment should support an analyst—it should never replace evidence or make claims about a person’s intent or legal responsibility.

Demo

You can explore the deployed application here:

Open the Suryakavacham Demo

The demo showcases the complete investigation workflow:

Create an investigation
Ingest media
Start preprocessing
Run forensic analysis modules
Review collected evidence
Fuse evidence from multiple sources
Generate an explainable assessment
Review mitigation recommendations
Generate a forensic report

The project repository is available here:

View the Suryakavacham Repository

Partner Technologies

I used several technologies to build Suryakavacham:

React and TypeScript

The frontend is built with React and TypeScript. TypeScript helped me create a more reliable and maintainable architecture by providing strongly typed data structures for investigations, media assets, analysis results, evidence objects, assessments, and reports.

TanStack Start and TanStack Router

TanStack Start and TanStack Router were used to create the application structure and file-based routing system. This made it easier to organise the many sections of the platform, including the dashboard, investigations, media vault, evidence explorer, reports, and system architecture pages.

Supabase and PostgreSQL

Supabase was used as the backend foundation for authentication, database operations, storage, and server-side functionality. PostgreSQL provides the data layer for investigations, media assets, analysis runs, evidence, assessments, review actions, reports, and audit events.

The application architecture is designed around authenticated access, private media storage, Row Level Security, and server-side processing.

Tailwind CSS

Tailwind CSS was used to build the visual interface. Since Suryakavacham is intended for cybersecurity professionals and digital investigators, I focused on creating an interface that is technical, professional, information-dense, and easy to navigate.

I intentionally avoided generic cyberpunk styling, excessive neon effects, and hacker clichés. Instead, the UI uses a high-trust forensic design language with clear status indicators, evidence cards, timelines, dashboards, and structured reports.

Lucide React

Lucide React was used for interface icons throughout the platform. The icons help users quickly understand actions such as uploading media, reviewing evidence, generating reports, inspecting metadata, and starting analysis.

jsPDF and JSZip

These libraries were used to support report generation and evidence export workflows. The goal is to allow investigators to create structured forensic reports and export relevant evidence in a practical format.

QRCode

QRCode functionality was included for verification-oriented workflows, such as generating records related to file hashes and forensic reports.

Working with these technologies helped me understand how frontend design, backend services, security, data modelling, and explainable AI workflows need to work together in a sensitive cybersecurity product.

Hackathon Experience

I built Suryakavacham as a project focused on the intersection of artificial intelligence, cybersecurity, media forensics, and responsible technology.

The hackathon experience gave me the opportunity to explore how a technical idea can be transformed into a complete product with a real user workflow. Instead of building only a model or a simple classifier, I wanted to create an end-to-end platform that considers investigation management, evidence collection, uncertainty, human review, mitigation, and reporting.

One of the most memorable parts of the experience was thinking about the ethical responsibility behind AI-powered media analysis. A system that detects potential manipulation should not automatically accuse people or present uncertain predictions as facts. This shaped the entire product design of Suryakavacham.

The project also helped me improve my understanding of:

Building complex interfaces with React and TypeScript
Designing modular analysis pipelines
Structuring evidence and forensic results
Creating secure media workflows
Communicating uncertainty in AI systems
Designing dashboards for professional users
Separating model output from observed evidence
Keeping human review as part of high-impact decisions

I am especially proud of the project’s central principle:

Evidence before verdict.

Suryakavacham is designed to help analysts see the signal, verify the source, and trust the evidence.

Smallwild

Sneha Ghosh — Thu, 08 Oct 2026 15:54:02 +0000

Smallwild

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

What I Built

Smallwild is an urban nature side-quest generator. Choose how much time you have, what kind of outdoor space is nearby, how you feel like moving, and something you are curious about. A local model turns those broad details into one short invitation to step outside and notice the ordinary wild around you.

It is for people whose nature is a street tree, a crack in the pavement, a courtyard, or a pocket of sky between buildings. There is no address field, GPS, map, route, species identification, pollution score, or safety verdict. The point is not to navigate a screen; it is to take one idea outside and look around.

Demo

Run it locally using the steps below. There is no deployed demo or field-test video included yet.

Code

This repository contains a static HTML, CSS, and JavaScript app. The browser sends the selected prompt to Ollama on the user's machine; there is no project backend and no remote AI API.

How I Built It

Smallwild uses Ollama to run an open-weight model locally. The default is gemma3:1b; the model field can be changed to any model already pulled into Ollama. A constrained prompt asks for a compact JSON quest: an invitation, three things to notice, a listening prompt, and a gentle closing thought. The app renders it as a printable field card. A tiny outing count is stored in local browser storage; no observations, locations, or profiles are saved.

To run it:

Install Ollama and pull a model, for example ollama pull gemma3:1b.
Start Ollama and allow the app's browser origin in Ollama's OLLAMA_ORIGINS setting. For a local app, that is http://localhost:8000. For a forwarded preview, use the exact origin shown in the app's connection error. If you run Ollama manually, for example: OLLAMA_ORIGINS="http://localhost:8000,https://<your-forwarded-app-origin>" ollama serve. If Ollama is already running as a service or desktop app, add the origin to its environment and restart it. Avoid OLLAMA_ORIGINS=* on a network-accessible machine.
In this repository, run python3 -m http.server 8000 and open http://localhost:8000.
Enter your local model's name in the form if you chose something other than gemma3:1b.

After downloading the model, inference and the app's assets can run locally. Smallwild does not fetch weather, air quality, maps, or location data. Its suggestions are creative prompts, not verified ecological facts or personal-safety advice; use your own judgment about where to go.

Why Does Open Innovation Matter?

The useful input here is personal but deliberately approximate: what kind of place is nearby and how much time someone has. A local open-weight model means even those broad clues do not need to go to a hosted API. The model is swappable, the prompt is inspectable, and the static app is easy to remix for another language, neighborhood, or model. Once the model is downloaded, generating a quest does not require a per-request service or an internet connection.

Open innovation also makes the limits visible. Smallwild does not pretend a language model can verify local species, weather, or outdoor safety. It makes a small creative suggestion, then gets out of the way. The tradeoff is that users need Ollama, a compatible device, and a locally downloaded model; response quality varies by model.

My Agent Session

Not included.

A Retrospective of My Hacktoberfest 2024 Experience

Sneha Ghosh — Fri, 01 Nov 2024 11:50:36 +0000

Introduction:

Hacktoberfest 2021 ~ Scenarios Of Learning, Challenges And Rewarding Experience This year’s Hacktoberfest brought new learnings, experiences, challenges and things to contemplate! In this article, I will walk you through what I learned, the highlights and some important takeaways from working on open-source projects.

Challenges Faced:

However one of the first issues I faced was trying to capitalize on any project able where I could apply my skills (HMTL, CSS, Javascript, three.js) could really contribute. Finding projects matching my skills with a learning curve took time.

What I Learned:

Collaborating in a Work Environment: Hacktoberfest
motivated me to work in the open-source collaboration. There was so much more to learn between submitting PRs, providing good descriptions, and receiving feedback, which really went into understanding version control/git, documenting, and making sure my code met certain standards after submission.
Technical Skill Development: I experienced practice for three. js, and so I challenged myself to understand how HTML, CSS and JavaScript can integrate to complement each other for better frontend contributions.
Improved Problem Solving: Each PR had a personality of its own with different problems that resulted in me to think outside the box!

Highlights:

a. _ Diverse Projects:_ Being involved in projects across different domains and bringing a new dimension to the table.

b. _ Meeting With Others:_ The chance to meet other contributors, bounce ideas off one another and collaborate was exciting. There is no community like Hacktoberfest community!

I feel accomplished! It was very rewarding and heavy experience which helped me to level up on aspects I did not see coming, with each PR.

This is my first time, and I am looking forward to contributing to more open source. This has encouraged me to pursue more difficult projects and grow as a developer!

Thanksfor giving this opportunity