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

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:

1. 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.

2. 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.

3. 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.

1. 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.

2. 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.

3. 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.