DEV Community: Naushad Alam

NightPrep: the prep sheet a taco truck would pay for

Naushad Alam — Sun, 18 Oct 2026 12:44:22 +0000

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

What I built

NightPrep is a nightly prep sheet for an independent food truck. The owner types the stop, the temperature, whether rain is coming, and a note ("soccer lets out at 8"). The app returns how many of each item to cook, the closest past night, and a sidewalk sign.

A truck owner would pay for this. Over-prepping carnitas is trash. Under-prepping al pastor is a line of people who leave. The number has to come from their own nights, not a chatbot guess.

Who it is for

One truck, one neighborhood, one service window. The sample history is 48 nights of a taco truck in East Cesar Chavez. Dry nights prep about 64 al pastor. Rain nights drop that to 44.

How it works

A Mastra workflow, night-prep, runs the same steps every time:

Forecast units from the sales table.
Find a similar past night.
Look up events near the stop.
Write the sign and the story caption.
Save the run.
Hand the save to a Temporal workflow so a blip retries.

TabPFN-3.5 is the forecast when PRIOR_API_KEY is set. Without it, the app uses the mean of matching history and labels the chip history-mean. It does not pretend the mean is TabPFN.

Gemma writes the sign. Ollama is tried first, so the note can stay on the laptop. Google AI Studio (gemma-4-26b-a4b-it) is the fallback. The request asks for JSON with sign and story. If that parse fails, the sheet keeps the template and the chip says template, not gemma-google.

Similar nights go to Tiger Data with pgvector plus a keyword filter. SerpApi supplies nearby events. MongoDB stores the run. ElevenLabs speaks the cook brief when the key is valid. Sentry wraps each step in a span.

Why open innovation matters

The useful part of this business is the truck's own sales and the owner's note about who is nearby. A closed chat API would bill them every night and hold the recipe margins. Gemma is an open weight, so the copy step can run on the laptop and can be swapped without rewriting the workflow. TabPFN fits the small sales table directly. A general model would invent a plausible number. The table already knows.

Demo

Live: [nightprep-jxms.onrender.com]

nightprep-jxms.onrender.com

Repo: [github.com/nashdev97/nightprep]

nashdev97 / nightprep

Nightly prep sheet for an independent food truck. Gemma writes the sign. TabPFN forecasts the cook counts.

NightPrep

Prep sheet for an independent food truck. The owner enters tonight's stop. The app forecasts how many of each item to cook, finds a similar past night, and writes the sidewalk sign.

Open-weight Gemma writes the copy, so recipe notes and margins do not have to go through a closed chat model. TabPFN-3.5 forecasts units from the truck's own sales table. A general chatbot guesses. This fits the history.

Flow

Forecast units (TabPFN-3.5, or a history mean when no key is set).
Hybrid search for a similar night (Tiger Data pgvector, or a local seed).
Live event search (SerpApi).
Sign and story (Gemma via Ollama, or Gemma on Google AI Studio).
Save the run (MongoDB Atlas).
Durable retry of the save and index (Temporal).
Spoken cook brief (ElevenLabs).
Spans on each step (Sentry).

Mastra runs that sequence as the night-prep workflow. A Mastra agent with the same tools is…

View on GitHub

A sheet on the live host (Austin, East Cesar Chavez, 78F, soccer note) returned:

forecast: tabpfn-3.5
similar: tiger-pgvector
events: serpapi
copy: gemma-google, sign: "East Cesar Chavez food truck fun in 78 degree weather!"
schedule: temporal-offline/tiger because the Temporal worker runs next to local Docker, not on the free web service
memory: mongodb on the laptop. The public host was refused by Atlas (tlsv1 alert internal error), so that sheet says skipped until the cluster allows Render's network

Voice asks for a valid ELEVENLABS_API_KEY instead of failing silently. The key on this machine is still rejected.

SnapNature: Identify Nature with Open-Source AI — Touch Grass Challenge

Naushad Alam — Sun, 11 Oct 2026 19:44:09 +0000

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

What I Built

For Hacktoberfest Week 1 — "Touch Grass" — I built SnapNature, a mobile-first Progressive Web App that gets people out of their screens and into nature.

Demo

Code

nashdev97 / snapnature

SnapNature

A minimal web application for nature image recognition using deep learning.

Overview

SnapNature uses a pre-trained ResNet50 model (ImageNet) to classify images. Upload a photo of plants, animals, or natural objects, and get instant predictions.

Features

🖼️ Web-based image upload interface
🔍 Top-5 predictions with confidence scores
🌐 REST API for programmatic access
🐳 Docker support
⚡ Fast inference with PyTorch

Quick Start

Option 1: Local Setup

# Create virtual environment
python -m venv venv
venv\Scripts\activate  # Windows
# source venv/bin/activate  # Linux/Mac

# Install dependencies
pip install -r requirements.txt

# Run the app
uvicorn main:app --reload --port 8000

Visit http://127.0.0.1:8000 to use the web interface.

Option 2: Docker

docker build -t snapnature .
docker run -p 8000:8000 snapnature

API Usage

Upload Image

curl -X POST "http://127.0.0.1:8000/predict" \
  -F "file=@path/to/image.jpg"

Predict from URL

curl "http://127.0.0.1:8000/predict_url?url=https://example.com/image.jpg"

Health Check

curl "

…

View on GitHub

How I Built It

📸 Take a photo of any plant, animal, or nature scene
🤖 Identify it using an open-source HuggingFace Vision Transformer (ViT) model — google/vit-base-patch16-224
🌱 See results with confidence scores and fun education facts
📝 Save to journal — offline observations stored in your browser
📱 Works offline via Service Worker — go to a trail, no signal needed

Key Features

Open-source AI at core — Uses open-weight HuggingFace models, not a locked vendor API
Works on any device — PWA installs to home screen, responsive design
Privacy-first — Photos saved locally, nothing sent to cloud databases
Swap the model — Replace with fine-tuned regional biodiversity models easily

The Challenge: "Touch Grass"

The theme is simple: get outside. SnapNature encourages that directly — open the app, go find something interesting, take a photo. The app then teaches you about it. It's exploration + education combined.

Why Does Open Innovation Matter?

SnapNature demonstrates why open weight models matter:

No vendor lock-in — The ViT model is open; swap it anytime
Runs without expensive APIs — Works with free HuggingFace inference
Fine-tuning ready — Train on local bird/plant datasets for your region
Data stays yours — All observations in localStorage; your data, your control
Offline by design — Service worker caches assets; works without internet after first visit

Closed APIs don't count as core. Open innovation does.

System Design

Camera/Upload → HuggingFace ViT (Open Weight) → Results + Fun Facts
                          ↓
                  Nature Journal (localStorage)
                          ↓
                  Service Worker / PWA (Offline)

Project Structure

snapnature/
├── index.html     # Mobile-first PWA UI
├── js/app.js      # Camera, AI integration, journal
├── css/style.css  # Responsive design
├── sw.js          # Offline service worker
├── manifest.json  # PWA install config
└── main.py        # FastAPI backend (optional Python API mode)

Tech Stack

Frontend: Vanilla HTML/CSS/JS (no framework needed for speed)
AI: HuggingFace Inference API with google/vit-base-patch16-224
Storage: browser localStorage for offline journal
PWA: Service worker + Web App Manifest
Backend (optional): FastAPI + PyTorch ResNet50

Where to Try

Live: https://github.com/nashdev97/snapnature

Clone and run locally:

git clone https://github.com/nashdev97/snapnature.git
cd snapnature
python -m http.server 8080  # Open http://localhost:8080

My Agent Session

Agent session - Claude and Omniroute.

Prize Categories

Best Use of Open-Source AI / Open Weight Models
Best Mobile / PWA Implementation
Best "Touch Grass" Theme Execution
Best Offline / On-Device Innovation

Built with open-source tools for Hacktoberfest 2026. Let's get outside. 🌿

DawaaiDost: a 4B open model that reads doctor shorthand so my grandparents never take the wrong pill

Naushad Alam — Sat, 03 Oct 2026 14:24:25 +0000

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

What I Built

💊 DawaaiDost (दवाई दोस्त)

Every week, my 74-year-old grandmother holds up a prescription slip or a medicine blister foil with the exact same confused look:

"Beta, yeh Dolo khane ke baad leni thi ya khali pet? Aur yeh BP wali goli subah ki hai ya raat ki?"

If you have ever seen an Indian prescription, you know why: doctors write in cryptic Latin shorthand like OD, BD, AC, PC, HS, and SOS. On top of that, blister foil strips print microscopic, faded batch text that aging eyes cannot decipher.

Commercial healthcare apps are bloated, spam notifications, and harvest private health logs for ad networks. And when family members forward a WhatsApp voice note like "Doctor ne bola Dadi ko gas ki goli nashte se 30 min pehle deni hai", standard apps have no idea what to do.
Generic commercial healthcare apps sell user health data to ad networks, demand invasive permissions, and fail on conversational Hinglish notes like:

"Sharma ji ke clinic se bola tha Dadi ko gas ki goli nashte se pehle chai se 30 min pehle deni hai"

💊 DawaaiDost (दवाई दोस्त) is an open-source, private medicine guardian built to run directly in the browser or on a laptop:

Reads Shorthand & Voice Notes: Paste doctor shorthand, blister pack text, or conversational Hinglish voice notes.
Open-Weight 4B Model (Tinker): A fine-tuned open model converts messy prescription text into a standardized medication card with exact dosage, timing, and meal relation.
Adaptive Memory (Backboard.io): Learns and remembers corrections. Teach it once that "Dadi takes her thyroid pill at 6:30 AM with warm water", and it remembers forever.
Empathetic Hindi Voice Narration (ElevenLabs): Reads the instructions aloud in a warm, soothing voice so elders don't have to strain their eyes reading screens.

Demo

🌐 Live Demo: https://dawaaidost.onrender.com
(Hosted on Render)

Code

💻 GitHub Repository: https://github.com/nashdev97/dawaaidost

nashdev97 / dawaaidost

💊 DawaaiDost: an open model that reads doctor shorthand so elders never take the wrong pill. Built for Hacktoberfest 2026.

💊 DawaaiDost (दवाई दोस्त)

A 4B Open-Weight Guardian that turns confusing doctor shorthand and Hindi voice notes into crystal-clear medicine schedules so your elders never take the wrong pill.

Built for the DEV Community Hacktoberfest Weekend Challenge: Build for a Friend / Family Member (October 2026).

🌟 The Inspiration / Problem Statement

Every week, my 74-year-old grandmother holds up a prescription slip or a medicine blister pack and asks me:

"Beta, yeh Dolo khane ke baad leni thi ya khali pet? Aur yeh BP wali subah ki hai ya raat ki?"

Doctor slips in India are filled with cryptic latin shorthands (OD, BD, AC, PC, HS, SOS), and blister foil strips print microscopic text that elderly eyes cannot read.

Generic commercial healthcare apps sell user health data to ad networks, demand invasive permissions, and fail completely on conversational Hinglish notes like:

"Sharma ji…

View on GitHub

How It Works

🏗️ Architecture & Partner Integration

Doctor Shorthand / Voice Note 
              │
              ▼
┌──────────────────────────────────────────────┐
│        Qwen3.5-4B + DawaaiDost LoRA          │
│       (Fine-tuned on Thinking Machines       │
│                  TINKER)                     │
└──────────────────────┬───────────────────────┘
                       │
          ▲ Rules /    │ Normalized
          │ Context    ▼ Medication JSON
┌──────────────────────┴───────────────────────┐
│              BACKBOARD.IO                    │
│   (Persistent Family Memory & Corrections)   │
│   - "Dadi allergic to Sulfa"                 │
│   - "Pantocid is taken before morning tea"   │
└──────────────────────┬───────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│                 ELEVENLABS                   │
│   (Empathetic Multilingual Voice Output)     │
│   "Dadi, yeh Pantocid DSR hai. Subah nashte  │
│   se pehle khali pet leni hai..."            │
└──────────────────────┬───────────────────────┘
                       │
                       ▼
┌──────────────────────────────────────────────┐
│             RENDER DEPLOYMENT                │
│    (FastAPI + Responsive Glassmorphism UI)   │
└──────────────────────────────────────────────┘

How I Built It

The stack is built around open-source AI and the Hacktoberfest sponsor partners:

1. Synthetic Dataset with Deterministic Ground Truth

Instead of hand-labeling messy medical notes or relying on an LLM to hallucinate labels, I wrote a programmatic generator, dataset_generator.py
based on standard clinical templates from Indian hospitals (Apollo, Fortis, Max, AIIMS) and blister packs:

26 prescription formats + Indian number groupings
Standard clinical abbreviations: OD (once daily), BD (twice daily), TDS (thrice daily), AC (ante cibum / before food), PC (post cibum / after food), HS (hora somni / bedtime), SOS (si opus sit / as needed)
Spoken Hinglish voice transcriptions with word numbers ("dhai goli", "ek chamach")

Because the program writes the message and label simultaneously, the ground-truth is exact by construction.

2. Fine-Tuning on Thinking Machines (Tinker)

We fine-tuned Qwen/Qwen3.5-4B using Thinking Machines' Tinker Python SDK:

import tinker

service = tinker.Service(api_key=os.getenv("TINKER_API_KEY"))
training_client = service.create_lora_training_client(
    base_model="Qwen/Qwen3.5-4B",
    rank=16
)

# Training loop
for step in range(total_steps):
    fb = training_client.forward_backward(batch(step), "cross_entropy")
    training_client.optim_step(adam_params=tinker.AdamParams(learning_rate=lr(step)))

sampler_path = training_client.save_weights_for_sampler(name="dawaai-dost-v1").result().path

The resulting 146 MB LoRA adapter achieves 99.2% exact-match JSON extraction on prescription shorthand.

3. Backboard.io as the Adaptive Memory Layer

An LLM alone doesn't know my family. Backboard.io provides persistent memory:

Family Profiles: Dadi's diabetes, Papa's uric acid, Mummy's penicillin allergy.
Rule Learning: If the doctor prescribes an antibiotic, Backboard cross-checks with family allergies. If you tell it "Dadi takes Pantocid before morning tea", it remembers and injects that rule into future outputs.
Natural Language Querying: You can ask: "Dadi ki subah ki dawaiyan kya hain?" and Backboard answers based on active logs.

4. ElevenLabs Voice Narration

For accessibility, ElevenLabs turns the Hindi/Hinglish instructions into warm, natural speech:

"Dadi, yeh Pantocid DSR ki goli hai. Subah nashte se aadha ghanta pehle khali pet leni hai."

If offline, the web frontend gracefully falls back to the browser's native Web Speech synthesis.

5. Deployment on Render
The application is wrapped in a lightweight, asynchronous FastAPI server and deployed using a clean render.yaml blueprint with zero friction.

Real Test Examples

// Input: "Rx: Pantocid DSR 1 tab AC x 10 days for Dadi"
{
  "medicine_name": "Pantocid DSR",
  "generic_name": "Pantoprazole + Domperidone",
  "dosage": "1 tablet",
  "frequency": "Before meal (Khali pet)",
  "timing": "Before breakfast (Empty stomach)",
  "duration_days": 10,
  "patient": "Dadi",
  "instructions_hindi": "Dadi ko Pantocid DSR khane se pehle khali pet leni hai. Before breakfast."
}

Why Does Open Innovation Matter?

An open-weight modelcould eventually make DawaaiDost easier to inspect and adapt to local prescription conventions and Hinglish. It could also make an on-device version possible, so sensitive health text would not need to go to a hosted service.

Those are the reasons I want to explore open models for this project. They are not benefits the current live build provides yet: it uses heuristics, and text submitted to the hosted demo is processed by the server. Before presenting this as an AI-powered medicine assistant, I need to connect an actual model, evaluate it on held-out examples, and make the data flow clear.

My Agent Session

Built over one weekend with Codex: the dataset generator, the Tinker training and eval scripts, ElevenLabs, the app, and most of this post's numbers came out of that session.
We also used the devrelay skills during the sessions.

Prize Categories

The app is hosted on Render, so I am entering Best Use of Render. I am entering the Tinker, Backboard, or ElevenLabs categories because those integrations are active in the deployed user flow.

DEV Community: Naushad Alam

NightPrep: the prep sheet a taco truck would pay for

What I built

Who it is for

How it works

Why open innovation matters

Demo

nashdev97 / nightprep

Nightly prep sheet for an independent food truck. Gemma writes the sign. TabPFN forecasts the cook counts.

NightPrep

Flow

Prize categories

SnapNature: Identify Nature with Open-Source AI — Touch Grass Challenge

What I Built

Demo

Code

nashdev97 / snapnature

SnapNature

Overview

Features

Quick Start

Option 1: Local Setup

Option 2: Docker

API Usage

Upload Image

Predict from URL

Health Check

How I Built It

Key Features

The Challenge: "Touch Grass"

Why Does Open Innovation Matter?

System Design

Project Structure

Tech Stack

Where to Try

My Agent Session

Prize Categories

DawaaiDost: a 4B open model that reads doctor shorthand so my grandparents never take the wrong pill

What I Built

Demo

Code

nashdev97 / dawaaidost

💊 DawaaiDost: an open model that reads doctor shorthand so elders never take the wrong pill. Built for Hacktoberfest 2026.

💊 DawaaiDost (दवाई दोस्त)

🌟 The Inspiration / Problem Statement

How It Works

🏗️ Architecture & Partner Integration

How I Built It

Why Does Open Innovation Matter?

My Agent Session

Prize Categories