DEV Community: Surendra Tripathi

MovAlong: A Zero-Cost, Air-Gapped RFC & Diagram Generator for Software Consultants

Surendra Tripathi — Sun, 18 Oct 2026 11:02:57 +0000

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

What I Built

If you do freelance software architecture, technical consulting, or backend contracting, you know the reality of the job: clients pay you to design systems, untangle legacy bottlenecks, and hand over clean, structured Request for Comments (RFC) documentation.

The best system design rarely happens while staring at a blank Markdown file. It happens when you step away from the keyboard, pace around the room, and talk through the edge cases out loud. The problem? Sitting back down to translate a 10-minute mental rant into a formal document with architecture flowcharts takes hours of unbillable admin work. Worse, if you are under a strict client NDA, you cannot dump proprietary architecture notes into a closed cloud LLM.

Enter MovAlong: Notes at your Pace. It is a brutalist, offline-first "Rubber Duck" built for freelance engineers, fractional CTOs, and technical consultants who want to turn spoken thoughts into billable architectural deliverables in seconds. It does three main things:

The Offline Voice Queue: You step away from your desk and talk through a system design problem ("Okay, if we migrate the client's session state from Postgres to a Redis cluster, we need to handle failover..."). Even with zero Wi-Fi, the browser records and queues the raw audio blobs locally in IndexedDB.
The Local Multimodal Pipeline: The moment you are back at your machine, the audio flushes to a FastAPI backend where PyTorch-accelerated OpenAI Whisper transcribes the recording locally on your GPU and pipes it to Gemma 2 9B.
The Staff Engineer & Mermaid Engine: Gemma 2 untangles the chaotic transcript into a structured, client-ready Markdown RFC (Summary, Motivation, Architecture, Trade-offs, Rollout Plan) and automatically writes Mermaid.js syntax, which the React UI intercepts and compiles into live SVG architecture diagrams.

Demo

Localhost Workspace Preview:

Note on the Demo: To stay true to the core value proposition of strict NDA compliance and zero API compute costs, the Whisper CUDA engine and Gemma 2 9B inference pipeline do not run in the cloud. They are hard-routed to localhost to execute exclusively on the user's local GPU. However, the workspace comes pre-seeded with 3 full architectural RFCs so you can test the brutalist UI, transcript toggle, and live Mermaid renderer immediately upon cloning!

The Brutalist Workspace & Live Mermaid Diagram

Code

Surendra-T / MovAlong

MovAlong

An offline-first developer tool that translates unstructured voice notes into formatted Request for Comments (RFCs) and live system architecture diagrams. Built entirely on local inference.

Above: MovAlong's brutalist workspace rendering a live Mermaid.js topology from a transcribed audio rant.

MovAlong was built to solve a specific engineering problem: the best system design happens when you step away from the keyboard and pace the room, but capturing those chaotic architectural thoughts is tedious.

Built during my continuing strides in open-source development, this tool operates as an asynchronous "rubber duck." By leveraging PyTorch-accelerated Whisper and Gemma 2 9B locally via Ollama, it untangles unstructured voice recordings into pristine Markdown documentation with absolute data sovereignty and zero runtime API costs.

System Architecture

The flowchart below details the offline-capable asynchronous queue and the local multimodal processing pipeline.

graph TD
    subgraph Client ["Browser / Frontend"]
        UI["React / Vite UI"]
        Recorder["HTML5 MediaRecorder"]
        IDB[("IndexedDB Audio

…

View on GitHub

How I Built It

I wanted to prove that you can build a heavy-duty, multimodal B2B developer tool (Audio -> Speech-to-Text -> LLM Structuring -> Live Diagram Rendering) entirely on consumer hardware—specifically my laptop's RTX 4070 (8GB VRAM) - without triggering Out-Of-Memory (OOM) crashes or paying a single cent in API tokens.

The Local AI Engine (Ollama + Gemma 2 9B): I used Ollama to serve Google's Gemma 2 9B locally. It acts as an automated Staff Engineer, taking messy spoken transcripts and enforcing a strict RFC schema. I also built an automatic self-healing retry loop in the backend (llm_service.py): if Gemma ever forgets to include a `mermaid diagram block on the first pass, the service catches it and prompts a targeted revision before saving.
The GPU Transcription Engine (Whisper on CUDA): I integrated openai-whisper directly into the Python 3.12 backend running on PyTorch with CUDA 12.4 (fp16 enabled). To keep VRAM balanced alongside a 9B parameter LLM on an 8GB card, I locked Whisper to the "base" model and wrapped it in a thread-safe lock so concurrent audio flushes never spike GPU memory.
The Offline Audio Engine: Built using the HTML5 MediaRecorder API, a real-time HTML5 <canvas> frequency waveform visualizer, and idb-keyval. Voice notes survive page refreshes and network drops, flushing sequentially in the background as soon as the server is reachable.
Workspace Isolation & Memory: I integrated MongoDB Atlas alongside custom bcrypt password hashing and PyJWT authentication. Every user gets an isolated workspace (owner_id scoped) that clones 3 idempotent reference architecture RFCs on sign-up and stores both the structured Markdown and the raw spoken transcript side-by-side.
The Brutalist Frontend: Built with React 18, Vite, and Tailwind CSS in a near-black (#0A0A0A) monochromatic palette using bundled @fontsource/geist-sans and @fontsource/geist-mono typography. It features one-click .md file exports and clipboard copying ready to drop straight into a client's GitHub PR or Notion workspace.

Why Does Open Innovation Matter?

If you are building a commercial tool for software consultants, agencies, or enterprise architects, closed-source APIs break the business model for two reasons: client confidentiality and unit economics.

Client Privacy & Strict NDA Compliance: When a freelancer is hired to redesign a fintech billing ledger or an internal healthcare pipeline, that architecture is sensitive IP. Shipping raw voice memos and system topologies to a third-party cloud API violates enterprise security policies. Because Whisper and Gemma 2 are open-weight and run locally on the laptop's GPU, client data never leaves the room. You can unplug your router, pace around recording a 10-minute architecture walkthrough, and generate the entire visual RFC completely air-gapped.
Zero-Marginal-Cost Unit Economics: Audio transcription + long-context LLM generation + diagram retry loops get expensive fast on closed APIs. If you sell a desktop developer tool for a flat one-time license (or use it internally to speed up your own fixed-bid consulting deliverables), cloud token bills eat your margins alive. By shifting the compute to open-weight models on local hardware, the marginal cost of generating an RFC drops to $0.00.
Deterministic Control: Open tooling allowed me to tightly couple Whisper's output directly into a custom Gemma 2 validation pipeline that guarantees valid Mermaid.js syntax—without worrying about a cloud provider silently deprecating a model snapshot or throttling rate limits right before a client deadline.

Locally-run Gemma2: 9B using Ollama on Win 11 Terminal]

My First User

Before packaging this up, I became the first heavy user of MovAlong to spec out the architecture of my own projects—and had a fellow backend developer friend test the workflow by ranting through a session-state migration problem from Postgres to Redis.

The immediate feedback was two-fold: watching a chaotic 2-minute spoken brain-dump automatically compile into a clean Markdown spec with a rendered Mermaid flowchart felt like magic, and having the Raw Transcript tab right next to the Rendered RFC tab was critical. Even when the lightweight Whisper base model occasionally misheard a niche technical acronym, Gemma 2's surrounding context reconstructed the architectural intent accurately, and the one-click .md export made it immediately usable in a real repository.

Prize Categories

I am submitting MovAlong for the following partner categories:

Google / Gemma: Best open-weight AI application using local Gemma 2 9B for technical RFC structuring and deterministic Mermaid.js diagram generation.
MongoDB Atlas: Best data architecture for multi-tenant JWT workspace isolation and idempotent RFC template seeding.

Stop typing out boilerplate architecture docs from scratch. Step away from the desk, talk through the system, and let local open-source AI draft the spec.

Desk to Dirt: Breaking Screen Inertia with Open-Weight AI (Pace-Bud)

Surendra Tripathi — Sun, 11 Oct 2026 19:26:11 +0000

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

What I Built

It’s 4:30 PM. Your eyes burn from staring at VS Code. You know you should step outside, but the mental friction of deciding where to go and what to do keeps you glued to your chair. Standard fitness apps expect you to already have your running shoes on. I wanted to build an app that actively kicks you out the door.

Enter Pace-Bud: an offline-resilient, "Desk-to-Dirt" micro-expedition generator.

Instead of passive tracking, Pace-Bud uses a single "Break My Screen" button. When clicked, the app calculates your exact local daylight remaining and generates a highly specific, time-sensitive outdoor micro-quest. It beams the dispatch to your earbuds, and the screen UI enters a minimalist "Outdoor Mode." If you switch tabs, the timer pauses—enforcing total screen detachment. While outside, you can record offline field notes that automatically sync and transcribe when you return to Wi-Fi.

Demo

Note on the Demo: To stay true to the core philosophy of absolute data privacy and zero runtime costs for runners, the Gemma 2 inference engine does not run in the cloud. It is hard-routed to localhost to run exclusively on the user's local GPU via Ollama. Clone the repo and spin it up to experience the full AI concierge!

Code

Surendra-T / Pace-Bud

Pace-Bud

An offline-resilient, voice-activated micro-expedition generator designed to break screen inertia using open-weight AI.

Pace-Bud is a fully open-source React/FastAPI application built for the Hacktoberfest 2026 "Touch Grass" challenge. It actively targets desk fatigue by calculating local daylight windows and generating spontaneous, time-sensitive outdoor routing dispatches. It features a decentralized, zero-signal audio queue, allowing runners to log field observations entirely offline, syncing only when network connectivity is restored.

System Architecture & Features

Astronomical Daylight Calculation: Computes exact local sunset and remaining daylight minutes via ephemeris (astral), triggering time-sensitive dispatch windows.
Open-Weight AI Dispatches: Leverages Google's Gemma 2 9B (via local Ollama) to generate concise, location-aware outdoor objectives without relying on proprietary cloud LLM providers.
Decentralized Audio Field Queue (Offline Mode): Captures voice logs in zero-signal environments. Audio blobs are saved locally via browser IndexedDB (idb-keyval) and synced asynchronously when the device regains connectivity.
Resilient Run Telemetry:…

View on GitHub

How I Built It

My goal was to prove that you can build highly resilient, context-aware outdoor workflows without relying on fragile cloud APIs that crash the moment you enter a forest dead-zone.

The Local AI Engine: I used Ollama to run Google's Gemma 2 9B on my local RTX 4070. It acts as the "Continental Concierge," generating the stoic outdoor objectives and tagging the natural elements found in my field notes.
The Offline Audio Queue: I bypassed standard speech-to-text APIs (which fail without Wi-Fi) by using the browser's native HTML5 MediaRecorder and IndexedDB. When you record a voice note on the trail, the audio blob is saved locally to your device.
The Sync Engine: A FastAPI backend wrapped in a Temporal workflow automatically detects when network connectivity is restored, flushes the queue, transcribes the audio, and saves the field log.
The Voice: To ensure the screen stays in your pocket, I hooked up the ElevenLabs API to stream Gemma's dispatches in a crystal-clear, stoic "John Wick" voice straight to your earbuds.
The Telemetry & Memory: I integrated MongoDB Atlas as a time-series database. When you return from a run, the app charts your "Dopamine Delta" (pre- vs. post-run mood) against your Apple Health biometric data and remaining daylight.
The Frontend: Built with React (Vite) and Tailwind CSS, featuring bespoke "old-money" luxury themes and a wall-clock delta timer that leverages the Page Visibility API to log "pocket time" versus "screen time."

Why Does Open Innovation Matter?

The biggest lie in outdoor fitness tech is the assumption of continuous 5G.

Closed-source wrapper apps fail spectacularly when you are deep in the woods. Furthermore, proprietary algorithms optimize for one thing: keeping your eyeballs glued to their feeds.

Open-Weight models like Gemma 2 change the paradigm. By running the inference entirely on local hardware, Pace-Bud operates at zero-runtime cost. More importantly, its sole optimization metric is getting you away from the computer. Logging exact GPS coordinates, biometric health data, and mental health mood-scores requires absolute data sovereignty. With local open-source inference, my physical and mental data never touches a corporate server.

Prize Categories

I am officially throwing Pace-Bud into the ring for the following Hacktoberfest partner categories:

Best Use of Gemma: Best open-weight AI application using local Gemma 2 9B for location privacy.
Best Use of MongoDB Atlas: Best time-series backend for biometric vector storage and mood-tracking.
Best Use of ElevenLabs: Best Voice/Audio AI integration for screen-free outdoor interactions.
Best Use of Temporal: Best robust retry workflow for the offline field-log queue.

SiloFocus: A Zero-Cost, Local AI Study Companion Built for My Sister

Surendra Tripathi — Sun, 04 Oct 2026 20:12:15 +0000

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

What I Built

My younger sister is currently in the trenches preparing for her 12th-grade board examinations. If you've been there, you know the cycle, and the everyday monotonicity that it carries: stare at a brutal Calculus problem, get frustrated, switch tabs to 'take a quick break', and suddenly lose 45 minutes to scrolling.

I wanted to build her a focus environment that actually understands her stress rather than just aggressively ticking down a timer.

Enter 'SiloFocus'. It's a hyper-customizable, privacy-first study dashboard that blends a fluid and kinetic Pomodoro timer with a local AI tutor or an older brother/mentor. It does three main things:

The Timepiece: A distraction-free, beautifully animated study clock with procedural, zero-asset audio (grandfather clock ticks & singing bowl chimes generated directly in the browser).
The Socratic Tutor: A slide-out sidebar where she can dump a physics or a math problem and get instantm step-by-step doubt clarification formatted in clean LaTeX.
The Procrastination Interceptor: If the app detects she's abandoned her tab for too long during a study block, it pauses the timer and generates a humorous, personalized reality-check based on her recent study history to gently nudge her back into flow.

Demo

Live Web Dashboard (UI/UX Preview): https://silofocus.onrender.com/

Note on the Live Demo: The Render link showcases the kinetic UI, audio engine, and task workflows. However, to stay true to my core philosophy of "absolute data privacy" and "zero API costs" for students, the Gemma 2 inference engine and Mastra agents do not run in the cloud. They are hard-routed to localhost to run exclusively on the user's local GPU. To experience the AI tutor, clone the repo and spin it up locally!

Code

GitHub Repo Link: https://github.com/Surendra-T/SiloFocus

How I Built It

My current area of interest as well as my curiosity pushed me to prove that you don't need expensive cloud APIs to build elite, multimodal AI tools.
The entire brain of this app runs locally on my laptop's RTX 4070.

The Local AI Engine: I used Ollama to run Google's Gemma 2 9B. It handles all the heavy lifting; explaining thermodynamics, formatting KaTeX math equations, & generating motivational nudges.
The Orchestrator: I used Mastra framework to handle the complex state machine.
Mastra orchestrates two agents: a studyAgent for academic doubts & a nudgeAgent that intercepts procrastination.
The Memory: I integrated MongoDB Atlas to track her daily mood and productivity scores. When she loses focus, the nudgeAgent queries Atlas to ground its motivation in reality (eg: "Hey, you felt like a 4/10 last Tuesday but still crushed 50 minutes of Chemistry. Close the tab. You've got this.")
The Voice: To reduce screen & typing fatigue as well as the time consumed in typing, she can use voice dictation to ask questions. I hooked up the ElevenLabs API to stream Gemma's answers back in crystal-clear audio. (I also built a graceful fallback to native browser TTS so the project remains 100% open-source friendly if someone doesn't have an API key).
The Telemetry: I wrapped the local inference routes in Sentry tracing. It was incredibly satisfying to watch the Sentry dashboard prove that my local Gemma 2 setup was hitting sub-second latency with zero cloud costs.
The Frontend UI: Built with Next.js (App Router), styled with Tailwind, and deployed on **Render. I spent way too much time tweaking & playing around with CSS spring physics (tabular-nums and translate3d) to make the clock digits roll smoothly at 60fps.

Why Does Open Innovation Matter?

High school students are stressed, and frankly, they are broke. The idea that a student needs to pay a 200-300 rupees or $20/month subscription just to keep the ads off and have an AI explain a math concept is wild to me.

Open-Weight models like the Gemma family, change the game. By running the inference entirely on local hardware, SiloFocus operates at zero-runtime cost.

More important, it guarantees absolute data privacy. A student's mood, their struggles with a subject, and their study habits are deeply personal. With a closed API, that data gets shipped off to a corporate server to train future models and to run targeted ad-campaigns.
With SiloFocus and open-source local inference, her data stays exactly where it belongs: in her own room, on her own system.

Prize Categories

I am officially throwing SiloFocus into the ring for the following Hacktoberfest partner categories:

Weekend Challenge: Build for a Friend (The core inspiration for the project)
Google/Gemma (Best open-weight AI application using local Gemma 2 9B)
Mastra (Best agenting workflow and state orchestration)
ElevenLabs (Best Voice/Audio AI integration)
MongoDB Atlas (Best AI Memory & Data Architecture)
Sentry (Best AI Observability and local LLM latency tracing)
Render (Best deployment)