DEV Community: ANSH TAYAL

ScholarFlow: Automating the Brutal Academic Cold-Email Grind (100% Client-Side)

ANSH TAYAL — Sun, 25 Oct 2026 18:07:05 +0000

ScholarFlow: Automating the Brutal Academic Cold-Email Grind (100% Client-Side)

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

🦥 The Prompt: Channeling Our Inner Sloth

This week's challenge celebrates International Sloth Day with a clear directive: build something that rewards laziness by automating a task you genuinely dread.

If you have ever been an undergraduate or postgraduate student looking for a winter or summer research internship, you already know the single most demoralizing, high-friction chore in academia:

Cold emailing university professors.

The manual process is a slow nightmare:

Endless Department Hunting: Spending 30+ hours clicking through archaic, broken departmental webpages across dozens of IITs, NITs, and IIITs just to find who is actually researching your subfield.
The 3-Hour Email Agony: Either sending a generic "Respected Sir" template that gets deleted in 3 seconds, or spending 2 exhausting hours parsing a single research paper to write a 120-word email.
Forgotten Follow-ups: Outreach dates, 7-day follow-up cadences, and interview notes get lost in messy Google Sheets or buried under hundreds of inbox threads.

To solve this, I built ScholarFlow—a private, 100% client-side academic outreach and research preparation workspace designed to turn a 40-hour grind into a 2-minute workflow.

🚀 Live Demo & Repository

🌐 Live Web App: https://scholarflow-psi.vercel.app
💻 GitHub Repository: https://github.com/wide-shunks-67/ScholarFlow

⚡ The "Lazy Payoff": What ScholarFlow Actually Automates

The Manual Grind (Before)	With ScholarFlow (After)	Effort Saved
Finding Faculty: Manually searching 71 individual college websites across 100+ departments.	Instant Directory Search: Filter 7,055 faculty listings by institute, department, or keyword pills in milliseconds.	~25 Hours
Drafting Outreach: Blank page paralysis trying to balance humility and technical alignment.	Email Studio: 5 battle-tested templates with heuristic research alignment and live word counting.	~10 Hours
Interview Nervousness: Stumbling over your words when a professor asks for a quick phone call.	Voice Pitch Practice: Native browser Web Speech Synthesis speaks a 30-second elevator pitch aloud for rehearsal.	Priceless
Tracking Pipeline: Manually calculating follow-up deadlines and updating color-coded spreadsheets.	1-Click Pipeline Tracker: Automatic +7 day follow-up calculation and one-click CSV export.	~5 Hours

🌟 Core Features Walkthrough

1. 🏛️ Curated Directory of 7,055 Faculty Mentors

Instead of hunting down faculty listings from scratch, ScholarFlow bundles 7,055 faculty listings compiled from public institutional listings across 71 premier Indian engineering institutions (IIT Bombay, IIT Delhi, IIT Madras, IIT Roorkee, IIT Kharagpur, IIT Kanpur, IIT Hyderabad, IISc Bangalore, 25+ NITs, IIITs, and Central Universities).

Fast Filter Controls: Search by name, department, institute, or click quick focus chips (Machine Learning, Computer Vision, Robotics & Control, VLSI & Nanoelectronics, CFD, Bioinformatics, Cryptography).
Direct Actions: One-click launch into the Email Studio with the mentor pre-selected, or copy their email directly.

2. ✍️ Academic Email Studio

Professors receive hundreds of emails every week; they ignore generic flattery and long essays. ScholarFlow enforces academic best practices:

5 Structured Outreach Templates:
- Template A (Targeted Research Match): Aligns your project repository with the professor's listed research areas.
- Template B (Early Learner & Foundations): Tailored for 1st/2nd years emphasizing mathematical foundations and quick ramp-up.
- Template C (Formal Lab Inquiry): Respectful institutional format for official departmental programs.
- Template D (7-Day Polite Follow-Up): Respectful check-in sharing updated project progress.
- Template E (14-Day Final Closeout): Graceful sign-off keeping doors open for future cycles.
Concise Word Counter: Enforces a clean target (<180 words) so your message is readable on a smartphone in under 45 seconds.
Direct Mailto Launch: Launches your operating system's native email client with subject, recipient, and body pre-populated.

3. 🎙️ 30-Second Elevator Pitch Vocalizer

When a professor replies: "Can you jump on a quick 5-minute call?", students often freeze. ScholarFlow generates a concise 30-second conversational summary and reads it aloud using the browser's native Web Speech Synthesis API so you can rehearse your verbal delivery before screening interviews.

4. 🗺️ 6-Week Preparation Roadmap

Outreach without technical preparation rarely succeeds. ScholarFlow includes a 23-task checklist across 6 methodical stages:

Week 1: Choose a Direction & Assess Foundations
Week 2: Literature & Baseline Reproduction
Week 3: Public Artifact & GitHub Report
Week 4: Target List & Outreach Wave 1
Week 5: Outreach Wave 2 & Polite Follow-ups
Week 6: Interview Preparation & Wrap-Up

All task checkboxes and completion percentages save in real time.

5. 📊 Outreach Pipeline Tracker

Track applications across 5 stages: To Contact ➔ Applied ➔ Follow-up Sent ➔ Interview ➔ Accepted.
Automatic follow-up calculation (+7 days from date of application).
1-Click CSV Export: Download your entire pipeline anytime as a spreadsheet.

🛠️ Architecture: Why 100% Client-Side & Open Innovation Matter

Early in development, the project had a Python backend and cloud databases. But I took a step back and asked: Why does a student productivity tool need a remote server holding sensitive student data and tracking applications?

It doesn't. Making ScholarFlow 100% client-side offered massive advantages:

flowchart TD
    subgraph Browser ["Student Browser (100% Client-Side)"]
        UI["Landing Page & Workspace UI (Tailwind CSS)"]
        Router["Client-Side Router (#/ & #/app)"]
        Memory["In-Memory Dataset (7,055 Mentors)"]
        Speech["Web Speech Synthesis API (Voice Pitch)"]
        Storage["localStorage (Profiles, Roadmap, Pipeline)"]
        Mail["Native mailto: Protocol / Clipboard"]
    end

    UI --> Router
    Router --> Memory
    Router --> Storage
    Router --> Speech
    Router --> Mail

1. Zero Infrastructure Costs & True Portability

Because everything runs in static HTML, CSS, and JavaScript, the app costs $0.00 to host, requires no database maintenance, and can be deployed in seconds to any static host (Vercel, GitHub Pages, or Netlify). It even works by double-clicking index.html locally without an internet connection!

2. Radical Privacy by Design

Student profiles, GPA details, project repositories, and outreach notes are saved solely in the user's browser localStorage. No data, cookies, or tracking events are ever sent to remote servers or third-party databases.

3. Native Web APIs Over Heavy External Services

Instead of paying for third-party cloud speech APIs, ScholarFlow utilizes the browser's built-in window.speechSynthesis. The audio is generated directly on the device with zero latency and zero data transfer.

🎯 Summary & Reflection

Building ScholarFlow was an exercise in stripping away unnecessary complexity. By removing server bloat and focusing entirely on user friction, the project solves a real problem for thousands of engineering students across India.

If you are a student preparing for winter or summer research outreach, feel free to try ScholarFlow and let me know your thoughts!

Live App: scholarflow-psi.vercel.app
Source Code: github.com/wide-shunks-67/ScholarFlow

CraftOptima — Open-Weight AI Listing Optimizer for Artisan Side-Hustles

ANSH TAYAL — Sun, 18 Oct 2026 15:40:31 +0000

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

What I Built

Independent artisans, ceramicists, woodworkers, and solo makers create extraordinary handmade products. But selling online demands a grueling, separate skillset: decoding platform search algorithms, writing persuasive copy, and battling psychological underpricing against mass-market dropshippers.

CraftOptima is an open-weight AI listing strategist and e-commerce optimization engine engineered specifically for boutique creators and side-hustlers selling on Etsy, eBay, and Shopify.

Instead of forcing makers into closed corporate ecosystems with expensive monthly subscriptions, CraftOptima uses Google's open-weight Gemma model family to transform raw product concepts, craft methods, and rough cost estimates into a complete, high-converting marketplace kit in seconds:

🎯 Algorithm-Optimized Title: Platform-aware, keyword-dense titles tuned to marketplace limits (e.g., Etsy 140-char max, eBay search intent) with live character counters.
🏷️ Exactly 13 Search Algorithm Tags: Formatted precisely for Etsy's 13-tag limit and eBay search tags, discoverable by long-tail buyers without hashtag spam.
💰 3-Tier Psychological Pricing Matrix:
- Fast-Mover: High-velocity tier to build early shop review momentum.
- Artisan Sweet Spot: Recommended sustainable retail price protecting margins.
- Premium Gift Box: High-margin unboxing and gifting tier.
📖 Sensory Artisan Origin Story: 80–120 words of emotive craft narrative emphasizing hand-worked provenance.
📋 Structured Specs & Care Tips: Detailed bullet points with shipping and care guidelines to cut dispute and return rates.
🔊 30-Second AI Voiceover Commercial: Neural voice pitch generated with ElevenLabs (Sarah voice) for Instagram Reels and TikTok.
📦 Device-Isolated Seller Catalog: Private catalog backed by MongoDB Atlas with one-click saves and ownership-verified deletions — no creator ever sees another seller's private data or pricing strategies.
🎨 Responsive UI with Dark Mode: Clean light-blue default theme, dark mode toggle, mobile-responsive layout, and silent background server warmup.

Demo

🌐 Live Web Application: https://craftoptima.vercel.app/
⚡ Interactive Backend API & Docs: https://craftoptima.onrender.com/docs
💻 Source Code Repository: GitHub — wide-shunks-67/CraftOptima

Try it right in the live app with one of the quick presets (Ceramic Matcha Bowl, Soy Ember Candle, or Leather Cardholder).

Why Open Innovation Matters for Artisans

Commercial closed AI platforms (OpenAI, Anthropic) pose critical hazards for solo artisans:

Protecting Proprietary Trade Secrets: When an artisan inputs unique glaze formulations, leather tooling patterns, or rare craft workflows into closed proprietary APIs, their IP can be ingested into commercial training corpora. Open-weight models like Gemma guarantee private execution without proprietary trade secret exfiltration.
Side-Hustle Unit Economics: Traditional e-commerce SaaS platforms charge $30 to $80 month. For a creator clearing $300 month on weekends, SaaS fees crush profitability. Open-weight AI dramatically lowers inference costs, making it possible to run on low-cost compute or local Ollama hardware.
Zero Vendor Lock-In: Proprietary APIs deprecate endpoints, change terms, or hike prices without warning. Open weights cannot be retroactively revoked or price-hiked.
Strict Schema Compliance: General conversational models drift into wordy preambles. Pairing Gemma with constrained schema decoding (response_schema=ListingResponse) guarantees deterministic, typed JSON structures that plug directly into marketplace fields.

Partner Technologies Used

CraftOptima was built from the ground up utilizing the Hacktoberfest 2026 partner ecosystem:

1. 🔷 Google Gemma (Best Use of Gemma)

Model: gemma-4-26b-a4b-it via the official google-genai SDK.
Constrained Decoding: Enforces strict Pydantic JSON schemas directly during inference so titles, 13 tags, and 3-tier pricing arrays never fail schema validation.

2. 🚀 Render (Best Use of Render)

Deployment: Zero-downtime ASGI deployment configured via root render.yaml.
Backend Architecture: High-performance FastAPI server running on Python 3.12 with Uvicorn, serving CORS-enabled endpoints with automatic API documentation.

3. 🍃 MongoDB Atlas (Best Use of MongoDB Atlas)

Async Driver: Utilizes motor.motor_asyncio for non-blocking database queries.
Tenant Isolation: Enforces strict per-device user_id filtering on both read and write operations.
Secure Deletion: Ensures only verified owners can delete catalog listings from the Atlas cluster.

4. 🎙️ ElevenLabs (Best Use of ElevenLabs)

Model: eleven_turbo_v2_5 streaming endpoint.
Voice Synthesis: Synthesizes the generated 30-second artisan audio script into commercial-ready MP3 audio for short-form social media marketing.

Challenges Faced & Key Learnings

The JSON Malformed String Trap: LLMs frequently produce unescaped interior double quotes when describing product dimensions (e.g., 8" jar) or quoting customer sentiments. Standard json.loads breaks on unescaped internal quotes and raw newlines. We solved this by pairing Pydantic's response_schema with a regex-powered repair pipeline in _clean_json that normalizes control characters and repairs unterminated strings.
Cold Starts on Free Compute: Render's free tier spins down after 15 minutes of inactivity. To prevent mobile users from assuming the app was frozen, we built a silent background warmup ping (GET /api/health) triggered as soon as the frontend loads, paired with staged status notifications in the UI.
Cross-User Data Protection Without Auth Bloat: For solo artisans, forcing an OAuth login screen causes immediate bounce rates. Instead, CraftOptima generates persistent cryptographic device UUIDs, isolating MongoDB Atlas queries and verifying ownership before any record deletion.

What's Next for CraftOptima

Direct 1-click publishing via official Etsy and Shopify Partner REST APIs.
Image-to-listing analysis using Gemma multimodal vision models.
Automatic inventory sync and multi-currency pricing calculation based on current exchange rates.

CraftOptima was built with pride for creators, makers, and independent side-hustlers everywhere.

🌿 TrailMate: An Open-Source AI Copilot Helping Developers "Touch Grass"

ANSH TAYAL — Sun, 11 Oct 2026 13:26:25 +0000

🌲 The Modern Developer's Dilemma: Forgetting to "Touch Grass"

As developers, we spend hours immersed in abstract problem spaces: debugging asynchronous race conditions, optimizing build pipelines, and staring at high-refresh-rate monitors. Before we realize it, days slip by where our only connection to the physical world is the glare of the morning sun through closed window blinds.

When Hacktoberfest 2026 Week 1 announced its theme — "Touch Grass" — the mandate resonated immediately:

Build something with open-source AI at its core that gets people off the screen and into the world. The best builds should make the screen the shortest part of the experience.

Instead of building another chatbot that traps users in endless screen engagement, I asked a simple question: What if an AI was designed specifically to minimize screen time, maximize outdoor immersion, and get you outside in under two minutes?

Enter 🌿 TrailMate.

🚀 Live Demo & Open-Source Code

🌐 Live Application: trailmate-frontend.vercel.app
⚙️ Backend API: trailmate-2xn4.onrender.com
📂 GitHub Repository: github.com/wide-shunks-67/TrailMate (MIT Licensed)

🌿 What is TrailMate?

TrailMate is an open-source, AI-powered outdoor adventure copilot. By fusing real-time atmospheric intelligence with Google's state-of-the-art open-weight Gemma model (gemma-4-26b-a4b-it), TrailMate turns raw meteorological data into actionable, hyper-local, and delightfully restorative nature excursions.

Core Features

Hyper-Local Adventure Matchmaker: Generates 3 specific, real-world nature spots (parks, wetlands, trails, lakes) near your exact city, customized to your fitness tier and outdoor passions (hiking, birdwatching, stargazing, cycling, photography).
15-Minute "Touch Grass" Challenges: For busy developers who can't take a half-day hike, this generates an immediate, bite-sized mini-quest to step away from the desk right now.
Deep-Dive Roadmaps: Clicking an adventure reveals an interactive treasure-map style guide with starting point coordinates, chronological trail markers, sensory immersion quests, and secret ranger tips.
📅 Add to Calendar (.ics): Life gets busy. With one click, download a native .ics calendar invitation that schedules your outdoor break into Google Calendar, Apple Calendar, or Outlook.
📴 Offline Roadmap Export: Nature rarely has 5G reception. TrailMate lets you download your entire step-by-step roadmap as a .txt file so you can switch on Airplane Mode and navigate offline.
🔒 Private, User-Isolated Saved Trails: Bookmark trails to your personal collection. Each user and device gets an isolated private store via localStorage and MongoDB Atlas.
🔊 ElevenLabs Neural Audio Guides: Listen to spoken narrations of your trail itineraries before stepping outside.

💡 Why Open-Source & Open-Weight AI (Gemma) Matters

The prompt for this challenge posed a critical challenge: Why does open innovation matter for what you built?

Most consumer AI applications rely on closed, proprietary models. But for outdoor adventure and wellness tools, open-weight models like Google Gemma are a necessity, not just an alternative:

Dimension	Closed Proprietary AI	Open-Weight AI (Gemma) in TrailMate
Backcountry Privacy	Geolocation and expedition routes get sent to corporate servers and retained.	Zero Data Hoarding. Hiker locations and itineraries remain sovereign and edge-deployable.
Off-Grid Independence	Useless when cell towers drop in mountain valleys or state parks.	Open-weight architectures enable running quantized models locally on phones or ruggedized laptops with zero internet.
Predictable Costs	Per-token pricing and API rate-limits prevent scalable community tools.	Zero platform token tax. Accessible to non-profits, trail clubs, and park conservancies.
System Instruction Adherence	Guardrails often refuse or drift on localized survival guidelines.	Gemma can be deeply tailored with Leave-No-Trace (LNT) ethics and strict JSON schemas.

Using gemma-4-26b-a4b-it via the modern google-genai Python SDK allowed us to generate structured, JSON-guaranteed adventure itineraries that prioritize real outdoor safety, Leave No Trace principles, and immediate departure.

🏗️ System Architecture: The Decoupled Stack

TrailMate is built with a decoupled, high-performance architecture:

+--------------------------------------------------------------------------+
|                                CLIENT                                    |
|   Tailwind CSS + Vanilla JS Frontend (Hosted on Vercel Edge CDN)         |
+-------------------+----------------------------------+-------------------+
                    |                                  |
     (1) Local Geocoding & Weather            (3) User-Scoped Sync & Deep Dive
                    |                                  |
                    v                                  v
+-------------------------------+      +-----------------------------------+
|       OPEN-METEO API          |      |         RENDER BACKEND            |
| Free, Zero-Key Meteorological |      | FastAPI (Python 3.12 ASGI Server) |
| Hyperlocal Atmospheric Data   |      +-----------------+-----------------+
+-------------------------------+                        |
                                         (4) Gemma Inference via google-genai
                                                         |
                                                         v
                                       +-----------------------------------+
                                       |       GOOGLE GEMMA 4 MODEL        |
                                       |      (gemma-4-26b-a4b-it)         |
                                       +-----------------------------------+

Tech Stack:

AI Core: Google Gemma (gemma-4-26b-a4b-it) via google-genai SDK
Backend Framework: FastAPI (Python 3.12, Uvicorn ASGI)
Backend Deployment: Render Web Services
Frontend Framework: Vanilla JavaScript & Tailwind CSS
Frontend Hosting: Vercel
Database: MongoDB Atlas (User-scoped trail persistence)
Voice AI: ElevenLabs TTS
Weather API: Open-Meteo

🛠️ Engineering Deep-Dive: Two Tricky Bugs We Solved

Building for production in a hackathon always uncovers unexpected real-world edge cases. Here are two technical hurdles we tackled:

1. The Datacenter IP Rate-Limit Trap (Open-Meteo)

When we first deployed our backend on Render, our server-side weather requests started throwing 500 Internal Server Error.

The Cause: Free-tier cloud providers like Render share outbound public IP addresses among thousands of hosted containers. Open-Meteo enforces a fair-use limit of 10,000 requests/day per IP. Because Render's shared IP pool was exhausted by other web apps, our backend was rate-limited!
The Architectural Fix: We inverted the weather fetching architecture! Instead of routing weather queries through the server, we moved geocoding and forecast queries directly to the client's browser:

async function fetchWeatherLocally(locationStr) {
    // Queries Open-Meteo directly from the user's residential IP
    const geoRes = await fetch(`https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(locationStr)}&count=1&language=en&format=json`);
    const geoData = await geoRes.json();
    if (!geoData.results?.length) return null;

    const { latitude: lat, longitude: lon, name } = geoData.results[0];
    const weatherRes = await fetch(`https://api.open-meteo.com/v1/forecast?latitude=${lat}&longitude=${lon}&current=temperature_2m,weather_code,wind_speed_10m,relative_humidity_2m&timezone=auto`);
    const weatherData = await weatherRes.json();

    return { location: name, weather: weatherData.current, coordinates: [lat, lon] };
}

The browser fetches the live atmospheric metrics from the user's personal IP (which is never rate-limited), renders the weather widget immediately, and passes the meteorological context string ("21°C, Clear sky") to the Render backend for Gemma to reason over.

2. Private, Device-Scoped Saved Trails Without Heavy Auth

We wanted users to bookmark their favorite adventures without forcing them to register an account or fill out an annoying email-and-password form (which violates the spirit of rapid outdoor departure!).

The Problem: The initial database implementation saved all trails globally in MongoDB. When a user saved trails on their laptop and opened the app on their phone, the phone was fetching trails saved by other people!
The Solution: We implemented a hybrid storage system:
1. A unique, anonymous user_id is generated in localStorage on first visit.
2. Every trail saved is written immediately to localStorage (for instant zero-latency offline access).
3. The trail is synced to MongoDB Atlas tagged with that user_id.
4. The /api/saved?user_id=... endpoint filters strictly by the requesting device's ID.

🏃‍♂️ Taking It Outside: A Field Test

To put TrailMate to the ultimate test, I took it out into my local area.

I typed in my location, selected Walking and Relaxed pace, and clicked "Daily Challenge". Gemma suggested a 20-minute route to a nearby neighborhood greenway with a specific prompt:

"Walk to the northern boundary of the park, find a spot near the shaded treeline, and identify 3 distinct bird songs without checking your phone for 15 minutes."

I closed my laptop, walked out the door, and followed the challenge. Stepping away from the screen into the crisp afternoon air completely reset my mental clarity. It proved the core thesis of this project: when AI is focused on action rather than consumption, technology can be a bridge back to the real world.

🏆 Hacktoberfest 2026 Categories

TrailMate is proudly submitted to the Hacktoberfest Open-Source AI Challenge: Week 1 ("Touch Grass"):

Main Theme: Touch Grass (Open-source AI that gets people outside)
Best Use of Gemma: Utilizes Google's open-weight gemma-4-26b-a4b-it model via google-genai
Best Use of Render: Fully deployed and configured Python FastAPI ASGI service
Best Use of ElevenLabs: Audio narration guide for trail exploration
Best Use of MongoDB Atlas: Scalable document storage for private user-scoped trail collections

🌿 Final Thoughts

Open-weight AI gives developers the power to build tools that respect human dignity, data privacy, and connection with nature. We don't need more algorithms keeping us glued to our screens. We need technology that empowers us to close our laptops, put on our boots, and go touch grass.

If you want to try TrailMate for your next outdoor break, visit trailmate-frontend.vercel.app or explore the code on GitHub!

Happy exploring, and leave no trace! 🌿