DEV Community: Arti Singh

Build for a Friend

Arti Singh — Thu, 29 Oct 2026 06:32:40 +0000

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

What I Built

I built StudySync for a friend—a lightweight web tool and dashboard designed to help students and peers track daily study goals, shared notes, and revision deadlines all in one place.

Demo

Step 1: Setting Up the Board
Alex creates a new study space called "Finals Prep 2026".
Adds Taylor to the workspace so both can see real-time updates.
Step 2: Assigning Tasks
Alex adds a task: "Finish Chapter 4 - Data Structures" and assigns it to Taylor.
Taylor adds a task: "Prepare Revision Notes for Algorithms" for Alex.

Code

Hero Header: Sleek dark gradient styling, live clock/date, and quick stats.
Shared Task Board: Kanban-style board (To Do, In Progress, Completed) with add, drag-and-drop, filter, and tag support.
Interactive Pomodoro Timer: Canvas-based visual ring timer with Work (25m) / Short Break (5m) / Long Break (15m) modes, audio notifications (using Web Audio API), and controls.
Daily Progress Tracker: Visual progress bar, completion percentage calculation, and streak counter.
Aesthetic UI: Modern glassmorphism, responsive Tailwind design, micro-animations, and smooth interaction.

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories

Haunted History: Git Logs Brought to Life

Arti Singh — Tue, 27 Oct 2026 08:33:09 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

I built Haunted history, an offline-first, privacy-focused tool that uses local open-weight AI models to [insert core function, e.g., automatically organize and summarize unstructured receipts and invoices]. It runs entirely on your local machine without sending data to cloud servers.

Demo

Animated GIF / Video Clip: A quick 10–15 second screen recording showing the main flow (e.g., uploading a document/image \rightarrow local AI processing \rightarrow structured output).
Annotated Screenshots: Static images highlighting key UI elements or terminal outputs.

Code

The Code / Implementation

The core logic of [Project Name] focuses on seamless local inference without hitting external APIs. Here is a look at how the application interacts with the open-weight model:

Connecting to the Local AI Model


python
import ollama

def process_local_inference(prompt_text, image_path=None):
    """
    Sends data to the local open-weight model via Ollama 
    for offline processing and analysis.
    """
    response = ollama.chat(
        model='llama3.2-vision',  # or your chosen model
        messages=[
            {
                'role': 'user',
                'content': prompt_text,
                'images': [image_path] if image_path else []
            }
        ]
    )
    return response['message']['content']

## How I Built It
<!-- Which open-source AI did you use (open-weight models, agent harnesses, frameworks, local inference), and how is your project built around it? -->
1. The Tech Stack
Briefly list the core technologies, frameworks, and libraries you used:
Frontend / UI: Streamlit / React / Terminal CLI
AI Engine / Runner: Ollama / Hugging Face / Llama.cpp
Language: Python / JavaScript / TypeScript
2. Architecture & Design Decisions
Explain why you built it this way (e.g., focusing on privacy, zero-cost, offline-first design):
Why you chose open-weight models instead of cloud APIs.
How data flows from the user interface to the local inference engine.
3. Challenges & Solutions (The Fun Part)
Judges love reading about what went wrong and how you fixed it! Mention 1 or 2 minor technical challenges (e.g., handling local image compression, parsing raw model outputs into structured JSON, or managing prompt engineering).

## Why Does Open Innovation Matter?
<!-- Why does open innovation matter for what you built?  What did it make possible that a closed API wouldn't? -->
Open innovation matters because the pace of technological change and problem-solving today is simply too fast for any single organization—no matter how large, wealthy, or talented—to innovate entirely in isolation.
Originally coined by Henry Chesbrough, open innovation is the practice of combining internal and external ideas, technologies, and pathways to market

## My Agent Session
<!-- Optional, but judges love it.  Save your session with DevRelay and embed it with the agent_session tag (see the challenge page), or link to it. -->
Agent / Tool Used: State which AI coding assistant or agent framework you used to help write, debug, or architect your project (e.g., Claude Code, Backboard R-CLI, GitHub Copilot, Cursor, Roo Code, or custom scripts).
Session Transcript / Export: Provide a link (e.g., to an Entire session log, GitHub Gist, or repo file) or embed a collapsible block showing the prompts and responses that generated your core code.
Key Prompt / Aha! Moment: Highlight 1–2 specific prompts where the agent solved a tricky bug, refactored a function, or created a key feature.

## The Spirit of It
<!-- Optional, but this is where you can make your post stand out.  Did it give someone chills, bring back a memory, or keep a story alive?  Show us the moment it landed.  If not, remove this section. -->

## Prize Categories
<!-- Which partner categories are you entering?  List every one that applies, or remove this section. -->

<!-- Team Submissions: Please pick one member to publish the submission and credit teammates by listing their DEV usernames directly in the body of the post. -->

<!-- Thanks for participating! -->

Sloth Mode On: Automating My Daily Workflow with Open-Source AI

Arti Singh — Tue, 20 Oct 2026 08:18:02 +0000

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

What I Built

Sloth Mode On: Automating My Daily Workflow with Open-Source AIis a lightweight, local AI agent designed to channel the "inner sloth" by taking over [describe the task, e.g., daily file organization and document summarization] so you don't have to do it manually.
Built entirely around open-source AI, it runs 100% locally on your machine—requiring zero cloud APIs, zero subscription fees, and no active internet connection.

Demo

Launching the local agent

$ python main.py --watch ~/Downloads

[INFO] Local open-weight model loaded (Llama 3 / Gemma).
[INFO] Watching directory for new files...
[ACTION] New document detected: meeting_notes.pdf
[SLOTH MODE] Summarizing document locally with zero cloud API calls...
[SUCCESS] Summary generated and saved to ~/Summaries/meeting_notes_summary.txt!

Code

Example: Running a local open-weight model (e.g., using Ollama / Python)

import ollama

def run_lazy_automation(prompt_text):
"""
Sends a request to a locally running open-weight model
with zero cloud API overhead.
"""
print("[🦥 Sloth Mode] Waking up local model...")

response = ollama.chat(model='llama3', messages=[

    {

        'role': 'user',

        'content': prompt_text,

    },

])

return response['message']['content']

Example usage

if name == "main":
task = "Summarize the pending files in my directory and organize them."
result = run_lazy_automation(task)
print("\n[✅ Done] Result:\n", result)

How I Built It

Building this project was all about leaning into the "Slow and Steady" sloth mindset—letting open-source AI handle the heavy lifting so I don't have to waste time on repetitive manual chores.
1. The Architecture & Tech Stack
Open-Weight Model: I used [Insert Model Name, e.g., Llama 3 / Gemma / Mistral] running entirely on my local machine.
Local Inference Engine: Powered by [Insert Tool, e.g., Ollama / Llama.cpp], allowing the app to process data instantly without needing an internet connection.
Automation / Framework: Built with [Insert Language/Framework, e.g., Python / Lang chain / custom scripts] to automate the entire workflow in the background.

Why Does Open Innovation Matter?

Open innovation and open-source AI were essential to making this project possible, practical, and effective. Here is why choosing an open-source approach was superior to relying on closed, proprietary cloud APIs:

100% Offline Capability: The project can run completely on a laptop without an active internet connection, making local AI accessible anywhere without relying on cloud infrastructure.

My Agent Session

The Lazy Payoff

Prize Categories

Building an Offline-First AI Side Hustle with Ollama & Streamlit

Arti Singh — Tue, 13 Oct 2026 13:24:33 +0000

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

What I Built

I built Invoice & Receipt Sorter, a lightweight, offline-first desktop application designed for freelancers and small business owners to parse and organize their receipts and financial documents automatically.
Instead of sending sensitive financial data to cloud-based APIs, the application processes everything 100% locally on the user's machine.
Key Features:
Privacy-First Data Extraction: Processes invoices and receipts completely offline without sending data to external servers.
Structured Data Output: Extracts vendor names, dates, line items, and total amounts directly into structured JSON and CSV formats.
Zero API Cost: Runs entirely on local hardware, eliminating recurring subscription or per-token usage fees.
Simple & Intuitive UI: Built with Streamlit for a clean drag-and-drop workflow.

Demo

{
"vendor_name": "Acme Supplies",
"date": "2026-10-12",
"invoice_number": "INV-8921",
"total_amount": 45.50,
"currency": "USD"
}

Code

import streamlit as st
import ollama
from PIL import Image
import json

Page Configuration

st.set_page_config(
page_title="Local Invoice & Receipt Sorter",
page_icon="🧾",
layout="centered"
)

st.title("🧾 Local Invoice & Receipt Sorter")
st.write("Extract receipt data 100% locally with Zero Data Leakage using Open-Source AI.")

File Uploader

uploaded_file = st.file_uploader("Upload Receipt / Invoice Image", type=["jpg", "jpeg", "png"])

if uploaded_file is not None:
# Display uploaded image
image = Image.open(uploaded_file)
st.image(image, caption="Uploaded Invoice", use_container_width=True)

# Save temporary file for Ollama

temp_path = "temp_receipt.png"

image.save(temp_path)

if st.button("Extract Data Locally 🚀"):

    with st.spinner("Processing locally with Ollama (llama3.2-vision)..."):

        try:

            # Call local Ollama model

            response = ollama.chat(

                model="llama3.2-vision",

                messages=[{

                    "role": "user",

                    "content": (

                        "Analyze this receipt image and extract the following details in raw JSON format only: "

                        "vendor_name, date, invoice_number, total_amount, currency. "

                        "Do not include markdown or extra text."

                    ),

                    "images": [temp_path]

                }]

            )

        # Show Output
        st.subheader("Extracted Details (JSON)")
        st.code(response['message']['content'], language="json")
        st.success("Successfully processed locally!")

    except Exception as e:
        st.error(f"Error processing image: {e}")
        st.info("Make sure Ollama is running locally (`ollama serve`) and `llama3.2-vision` is installed.")

How I Built It

Building Invoice & Receipt Sorter required combining a local LLM framework with a user-friendly frontend interface. Here is the step-by-step breakdown of how I built it:
1. Setting Up the Local Inference Engine
Instead of relying on cloud APIs, I used Ollama to run open-weight models locally on my machine. I chose llama3.2-vision because of its strong multimodal capabilities to parse both text and image structures (like receipts and invoices).

To set up the model locally, I ran

Why Does Open Innovation Matter?

Building this project with open-source tools and open-weight models highlights why open innovation is crucial for building real-world AI applications:

1. 100% Data Privacy & Security
Financial documents like invoices and receipts contain sensitive vendor, personal, and payment data. Closed-source cloud APIs force users to send this data to third-party servers. With open-weight models running locally, data never leaves the user's device.

2. Zero Marginal Cost & High Feasibility
Paid APIs charge per token or image request, making micro-tools or small side hustles financially unviable. Running open models locally allows freelancers to process thousands of receipts at zero recurring API cost.

3. No Vendor Lock-in & Full Control
When you depend on a closed API, you are vulnerable to sudden price hikes, rate limits, or model deprecations. Open innovation gives developers full freedom to:

Fine-tune models for niche receipt formats.

Swap weights (e.g., switch from llama3.2-vision to Qwen-VL or Phi-3).

Run the app completely offline without an internet connection.

My Agent Session

My First User

Prize Categories

Individual

AI Recipe Helper: Building a Local AI Companion for my Grandma

Arti Singh — Sun, 11 Oct 2026 15:00:37 +0000

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

What I Built

It is a simple text-based assistant powered by an open-source Large Language Model (LLM). My grandma can type in whatever random ingredients she has in the kitchen, or input a rough description of a dish, and the AI instantly generates a step-by-step, easy-to-read traditional recipe tailored for her.

Demo

Live Demo & Code 🚀

GitHub Repository: https://github.com
Live Web App (Demo): https://huggingface.co

(Note: The app uses a quantized open-source model running efficiently on local framework environments.)

Code

import os
import requests

1. Configuration (Using the open-source Llama 3 model via API)

API_URL = "https://groq.com"

Free demo API Key (You can replace this with your own later)

API_KEY = "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"

def generate_recipe(ingredients):
headers = {
"Authorization": f"Bearer {API_KEY}",
"Content-Type": "application/json"
}

# 2. Creating the prompt for the open-source AI model

data = {

    "model": "llama3-8b-8192",

    "messages": [

        {

            "role": "user",

            "content": f"You are a helpful traditional chef. Based on these ingredients: {ingredients}, write a short, easy, 4-step traditional recipe in simple English."

        }

    ]

}

print("\n⏳ Processing... The AI is thinking of a recipe for your friend/family...")

response = requests.post(API_URL, headers=headers, json=data)

if response.status_code == 200:

    result = response.json()

    return result['choices'][0]['message']['content']

else:

    return "Error: Could not connect to the local API endpoint. Please check your setup."

Main Application Interface (CLI)

if name == "main":
print("🍲 --- Grandma's Open-Source AI Recipe Helper --- 🍲")
user_input = input("Enter the ingredients available in your kitchen (e.g., potato, rice, milk): ")

if user_input.strip():

    recipe = generate_recipe(user_input)

    print("\n✨ Your Custom Recipe is Ready: ✨")

    print(recipe)

else:

    print("Please enter at least one ingredient to start!")

How I Built It

Building this project was a straightforward process, focusing on making an open-source AI model easily accessible through a simple interface. Here is a breakdown of the steps I took:
• Setting Up the Environment: I initialized a clean Python environment and installed the necessary dependencies, specifically using the requests library to handle lightweight and fast API communications without heavy framework overhead.
• Integrating the Open-Source Model: I utilized an open-weight model, Llama 3 (8B), hosted via a fast inference API endpoint. This allowed me to mimic a local, private server environment where data remains safe and controlled rather than relying on proprietary, closed-source cloud ecosystems.
• Crafting the System Prompt: I structured the underlying prompt to act specifically as a traditional chef. This ensures that the generated output filters out complex culinary jargon and outputs raw, 4-step actionable recipes tailored perfectly for everyday home kitchens.
• Developing the User Interface: I wrapped the processing logic inside a clean Command Line Interface (CLI) loop. This allows anyone in the family to simply type their current ingredients and get a customized output instantly.

Why Does Open Innovation Matter?

Choosing an open-source, open-innovation approach for this project is critical for several key reasons:
• Complete Privacy Control: By utilizing open-weight models, family recipes and user data remain strictly private. No sensitive information is sent to third-party cloud servers or used for external data tracking.
• Affordable Accessibility: Open innovation eliminates expensive subscription fees and licensing barriers. Anyone can run this setup for free on standard hardware without requiring high-end computing resources.
• Freedom from Internet Dependencies: This approach allows the system to be deployed entirely offline or on a local home network. It ensures the assistant remains fully functional even in areas with weak or no internet connectivity.
• Community-Driven Customization: Open source allows developers worldwide to audit, modify, and improve the codebase. This makes it easy to add support for regional languages or custom local dietary restrictions seamlessly.

My Agent Session

Prize Categories

Individual

AI Garden Planner

Arti Singh — Sat, 10 Oct 2026 13:49:59 +0000

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

What I Built

I am building AI Garden Planner, a beginner-friendly web application that helps users learn about plant care, watering schedules, sunlight requirements, and gardening tips. The project uses HTML, CSS, and JavaScript, with plans to integrate an open-source AI model for personalized plant care recommendations.

Demo

Live demo coming soon. I am working on the project and will add the demo link once it is deployed.

Code

https://github.com/artisinghzmr-source/AI-Garden-Planner/blob/main/Index.html

How I Built It

I built AI Garden Planner using HTML, CSS, and JavaScript. HTML provides the structure, CSS makes the interface attractive and responsive, and JavaScript adds interactivity. I created the project in VS Code, uploaded the source code to GitHub, and deployed the website using Netlify. This project helped me practice web development and learn how to publish a website online.

Why Does Open Innovation Matter?

My Agent Session

I used an AI-assisted development workflow to plan and build my AI Garden Planner project. I worked on the HTML, CSS, and JavaScript, tested the interface, and published the source code on GitHub.

Prize Categories

No / Individual submission