# How to Vibe Code Your Own FileChanger (and Stop Paying for It) > The file converter that speaks technical formats - Site: https://filechanger.io - Category: Developer Tools - Verdict: **Solid side project** (65/100 vibecodeable) - Estimated effort: 2-3 weeks part-time ## Verdict You can build a functional personal clone of FileChanger, but containerizing and managing 40+ heavy CLI tools safely will test your DevOps patience. The API routing, authentication, and job polling loop are straightforward to build with an AI assistant. However, compiling and running a secure container image containing Typst, Pandoc, LibreOffice, and FFmpeg—while preventing remote code execution exploits from malicious file uploads—requires careful Docker configuration and worker isolation. For personal use, it is a rewarding weekend engineering project, though paying $39/mo is vastly cheaper than the infrastructure setup time if you just need the conversions. ### What you can't replicate - The exact battle-tested sandbox hardening against malicious format payloads - Official community nodes pre-published in n8n and Zapier app directories ## What it does A developer-focused utility SaaS that provides a unified API and Model Context Protocol (MCP) server for converting files across 40+ technical, document, image, audio, and video formats. ### Core features - REST API for asynchronous file conversion jobs (POST /api/jobs, polling status, output download) - Model Context Protocol (MCP) server integration for AI agent workflows - Support for niche markup engines (Typst, Pandoc, LaTeX, AsciiDoc, Org-mode, reStructuredText) - Audio and video transcoding engine via FFmpeg - Headless document rendering via LibreOffice and Ghostscript - API key management with secure hashing and rate-limiting - Pre-built community integrations (n8n, Zapier, Make) ## The business ### Pricing - Free: Free - Starter: $39/mo - Pro: $99/mo Founded 2024. Team size: 1-2. ## The hard parts - Secure sandboxing of untrusted user-submitted files running heavy native CLI binaries (RCE and security mitigation) - Managing and patching 40+ disparate CLI compilers, font dependencies, and system binaries without breaking format conversions - Robust asynchronous job queue orchestration for large binary media transcoding - Implementing and maintaining a compliant MCP server spec alongside standard REST endpoints ## How to vibe code FileChanger ### Prerequisites - Node.js (free): Required for running the Next.js frontend and TypeScript backend orchestrator. - Docker (free): Required to run isolated container workers containing FFmpeg, Pandoc, and Typst binaries. - GitHub (free): Code repository and deployment source control. ### Recommended AI tools - Claude Code: Best-in-class terminal agent for scaffolding the full-stack API, database schema, and worker queue logic. - Cursor: Ideal for fine-tuning the UI dashboard, API key management views, and MCP server endpoints. ### Stack - Frontend: Next.js - Backend: Node.js (Express) with BullMQ / Redis worker queues - Database: Turso (SQLite over HTTP) - Auth: better-auth - Payments: none - Other: Docker container pool, Pandoc / Typst / FFmpeg CLI binaries, Model Context Protocol SDK ### Hosting - Fly.io (Hosting the Node.js API orchestrator and persistent Docker worker machine with local file volumes): $5-10/mo - Vercel (Hosting the Next.js frontend dashboard and documentation pages): $0/mo ### Build guide 1. **Scaffold Next.js Dashboard and API Structure** — Initialize the Next.js project with Tailwind CSS, configure Turso database client, and set up better-auth for personal account management. ``` Create a new Next.js project with Tailwind CSS and TypeScript. Set up a Turso SQLite database connection using Drizzle ORM with tables for users, api_keys (with columns for hashed keys and prefixes), and conversion_jobs (columns for id, user_id, status, from_format, to_format, input_path, output_path, error, created_at). Implement better-auth for secure account sign-in and a dashboard page to generate and revoke API keys prefixed with 'fc_'. ``` 2. **Implement REST API Key Auth and Format Discovery Endpoint** — Build the middleware to validate the X-Api-Key header against hashed keys in the database and create the public GET /api/formats endpoint. ``` Implement API key authentication middleware in Next.js or Express that checks the 'X-Api-Key' request header, hashes it, and verifies it against the api_keys table. Add a public GET /api/formats endpoint that returns a JSON list of supported input formats (markdown, html, latex, rst, org, typst, docx, mp3, mp4, jpg, png, pdf, etc.) and output formats. Handle missing or invalid API keys with proper 401 and 403 JSON error responses matching the FileChanger spec. ``` 3. **Build Async Conversion Job Submission and Polling Endpoints** — Create the POST /api/jobs multipart file upload endpoint, store incoming files temporarily, queue a background job, and implement GET /api/jobs/{id} status polling. ``` Build the POST /api/jobs endpoint supporting multipart/form-data uploads with 'file', 'from', and 'to' form fields. Save the uploaded file to a secure temporary directory, insert a job record with status 'pending' into the database, and enqueue the job ID to an asynchronous worker queue (using Redis/BullMQ or a database-backed queue). Implement GET /api/jobs/{job_id} to return the current status ('pending', 'running', 'done', 'failed') and metadata, and GET /api/jobs/{job_id}/output to stream the converted file with correct Content-Type and Content-Disposition headers, deleting the temporary files immediately after delivery. ``` 4. **Containerize Conversion Engine with Pandoc, Typst, and FFmpeg** — Create a robust Dockerfile containing all required CLI binary tools and implement the background worker execution logic. ``` Create a Dockerfile based on Ubuntu or Debian that installs Node.js along with heavy conversion binaries: Pandoc, Typst, LibreOffice (headless), Ghostscript, and FFmpeg with common codecs. Write a background worker script that consumes queued jobs, inspects the 'from' and 'to' formats, and executes the appropriate CLI command safely (e.g., pandoc input.md -o output.docx, typst compile input.typ output.pdf, or ffmpeg -i input.mp4 output.webm). Ensure proper error handling, timeout protection for hanging processes, and cleanup of temp files. ``` 5. **Build Model Context Protocol (MCP) Server Integration** — Expose a built-in MCP server endpoint so AI agents can query formats and trigger conversion jobs directly. ``` Implement an MCP server integration within the backend codebase using the Model Context Protocol SDK. Expose tools that allow connected AI agents to list available conversion formats and execute conversion jobs by submitting file buffers or URLs, returning the conversion status and resulting file content. Ensure authentication and quota limits are enforced for MCP requests. ``` 6. **Polish Dashboard UI, Webhooks, and Error Handling** — Add usage metrics visualization, recent conversion history logs, and robust client error handling to the web dashboard. ``` Polish the Next.js web dashboard to display active API keys, monthly conversion quota usage broken down by format group (documents, images, audio, video), and a log table of recent conversion jobs with their status and download buttons. Add robust client-side validation and error state handling for failed conversions. ``` ### Cost vs paying **Starting costs (one-time):** - AI coding tool subscription: $20 - Total: ~$20 one-time **Ongoing costs (monthly):** - Fly.io persistent server / worker VM: $6-10/mo - Turso database & storage: $0/mo - Total: ~$6-10/mo - Paying for the SaaS instead: $39/mo (Starter plan) - Build time: 25-35 hours - AI tool credits: $20 (Claude Pro / Cursor Pro) - Break-even: Not about financial ROI; build for learning CLI orchestration and MCP servers, or pay $39/mo to skip the DevOps burden. ## Sources - [FileChanger Homepage](https://filechanger.io) - [FileChanger Documentation](https://filechanger.io/docs) - [FileChanger Pricing](https://filechanger.io/pricing)