# How to Vibe Code Your Own Auphonic (and Stop Paying for It)

> Your AI sound engineer for podcasts, videos, and audiobooks

- Site: https://auphonic.com
- Category: Audio & Video Post-Production SaaS
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused development and debugging

## Verdict

Build a personal subset with a Next.js frontend and a Python FastAPI backend running FFmpeg, but keep paying for the production-grade DSP and cloud rendering engine.

Vibecoding a simple audio file uploader that hits an FFmpeg normalization script is easy, but replicating Auphonic's robust suite of multi-stage AI noise reduction, adaptive leveling, multitrack ducking, and lightning-fast background processing queues is a serious multi-week systems engineering undertaking. Your AI coding agents will write clean React UIs and FastAPI routing boilerplate in minutes, but you will spend days debugging silent worker crashes during heavy audio rendering, stream memory leaks, and precise timeline timestamp math for filler-word cutting.

### What you can't replicate

- Over a decade of fine-tuned proprietary audio classification and restoration models
- Direct native partnerships and automated publishing integrations with hundreds of podcast networks
- Enterprise-grade distributed compute cluster optimized for ultra-fast parallel audio rendering

## What it does

Automated audio and video post-production web service offering noise reduction, intelligent levelers, loudness normalization, speech-to-text transcription, and publishing workflows.

### Core features

- Audio/Video upload & file processing queue
- AI Noise & Reverb Reduction (Spectral gating / source separation)
- Intelligent Adaptive Leveler (Dynamic range compression)
- AutoEQ, De-Esser, De-Plosive & Bandwidth Extension
- Filler word, cough & silence detection and cutting
- Multitrack ducking, noise gating & bleed removal
- Loudness Normalization (LUFS, EBU R128, ACX)
- Multilingual speech-to-text (OpenAI Whisper) & auto chapters
- Output encoding (MP3, AAC, FLAC) & metadata embedding
- Automated publishing via Webhooks, SFTP, and API

## The business

### Pricing

- Auphonic Free: Free — Free tier providing 2 hours of processed audio per month (includes Auphonic jingle).
- Recurring Credits (Auphonic S): €11/mo — Monthly subscription for 9 hours of processed audio per month.
- One-Time Credits: From €13 — Pay-as-you-go packages starting at 5 hours that never expire.

Founded 2013.
Team size: 1-10.

## The hard parts

- Mathematical audio DSP pipeline chaining (FFT filtering, compression, phase preservation)
- Asynchronous heavy compute queue architecture handling long-running audio renders without worker timeouts
- Multitrack alignment, cross-talk bleed analysis, and automated ducking state machines
- Accurate multilingual silence and filler-word detection mapped back to exact audio timeline millisecond timestamps

## How to vibe code Auphonic

### Prerequisites

- Node.js (free): Required for running the Next.js web application frontend and build tools.
- Python (free): Required for running the backend worker service, FFmpeg wrappers, and AI audio processing scripts.
- FFmpeg (free): Core system binary required for audio decoding, encoding, filtering, and loudness analysis.
- GitHub (free): Repository hosting for version control and deploying via Railway.

### Recommended AI tools

- Claude Code: Best-in-class terminal agent for scaffolding complex full-stack repositories, writing Python audio processing workers, and debugging FFmpeg integration errors.
- Cursor: Ideal for fine-tuning the Next.js frontend UI, managing component state, and reviewing code diffs visually.

### Stack

- Frontend: Next.js with Tailwind CSS and Shadcn/ui
- Backend: Python FastAPI with Celery and Redis
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: None (personal use clone)
- Other: FFmpeg for audio processing, OpenAI Whisper API for transcription, Cloudflare R2 for audio file storage

### Hosting

- Railway (Hosting the Python FastAPI backend server, Celery background worker queue, and Redis instance for handling long-running audio rendering jobs.): ~$10-15/mo
- Vercel (Hosting the Next.js frontend dashboard and web UI.): $0/mo
- Cloudflare (Storing raw audio inputs and mastered output files in R2 object storage with zero egress fees.): $0/mo

### Build guide

1. **Scaffold Monorepo & Database Schema** — Initialize a full-stack project with a Next.js frontend and a Python FastAPI backend. Set up Turso SQLite database schema for users, productions, and processing tasks.

```
Create a new full-stack project structure with a Next.js (App Router) frontend and a Python FastAPI backend. Configure better-auth for authentication with email/password. Set up a Turso SQLite database using Drizzle ORM with tables for users, productions (fields: id, user_id, title, status, settings_json, input_url, output_url, created_at), and processing_logs. Ensure proper TypeScript types on the frontend and Pydantic models on the backend. Add a clean Tailwind CSS layout with a sidebar and dashboard home page.
```

2. **Audio Upload & Cloudflare R2 Integration** — Implement secure file uploads for large audio and video files, piping them directly to Cloudflare R2 object storage.

```
Implement presigned URL upload endpoints in the FastAPI backend using boto3 compatible with Cloudflare R2 storage. On the Next.js frontend, build a robust drag-and-drop file uploader component supporting large audio/video files (MP3, WAV, FLAC, MP4) with a real-time progress bar. Handle upload chunking edge cases and save the resulting storage object key to the production record in the database.
```

3. **Asynchronous Processing Queue with Celery & Redis** — Configure Celery and Redis on Railway to handle long-running audio rendering jobs asynchronously without HTTP timeouts.

```
Configure Celery in the FastAPI backend using Redis as the message broker and result backend. Create a background task worker module that accepts a production ID, downloads the source audio file from Cloudflare R2 to a local ephemeral scratch directory, runs preliminary validation, and updates the production status table ('queued', 'processing', 'completed', 'failed') in real-time. Include robust exception handling that catches worker crashes and logs error details without leaving orphan locks.
```

4. **FFmpeg Audio DSP Pipeline & Loudness Normalization** — Build the core audio processing engine executing loudness normalization, filtering, and dynamic range compression via FFmpeg.

```
Write a Python audio processing pipeline service using subprocess calls to FFmpeg. Implement automated loudness normalization targeting EBU R128 (-23 LUFS) or podcast standards (-16 LUFS) using FFmpeg's loudnorm filter. Add filters for high-pass EQ, de-essing, and dynamic range compression based on user preset settings stored in the production JSON. Ensure temporary files are securely cleaned up from disk upon completion or failure.
```

5. **OpenAI Whisper Speech-to-Text & Transcript Editor** — Integrate OpenAI Whisper API for multilingual transcription, timestamp generation, and chapter extraction.

```
In the backend processing pipeline, add a step that sends extracted mono audio chunks to the OpenAI Whisper API for transcription with word-level timestamps. Parse the JSON response to generate structured chapter markers and a readable transcript. Build a Next.js interactive transcript editor component where users can view timestamped text blocks, search keywords, and export subtitles or shownotes in Markdown format.
```

6. **Production Dashboard & Real-time Status Polling** — Build the user dashboard showing production progress, audio preview players, and download links for finalized master files.

```
Build a comprehensive production details view in Next.js displaying processing logs, audio parameter settings, and real-time status updates via polling or server-sent events. Include an HTML5 audio waveform preview player using wavesurfer.js so users can listen to the mastered output file directly in the browser and download the encoded MP3, AAC, or FLAC results from Cloudflare R2.
```

### Cost vs paying

**Starting costs (one-time):**

- AI Coding Assistant (Claude Pro): $20
- Custom domain (optional): $12
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Railway Backend & Worker Hosting: $10
- Cloudflare R2 Storage & Bandwidth: $5
- Total: ~$15/mo

- Paying for the SaaS instead: €11/mo (Auphonic S plan)
- Build time: 35-50 hours
- AI tool credits: $20 (Claude Pro)
- Break-even: Never (paying €11/mo for Auphonic is cheaper than hosting compute and paying API fees)

## Sources

- [Auphonic Official Website & Features](https://auphonic.com)
- [Auphonic Pricing & Credit System](https://auphonic.com/pricing)
- [Auphonic Help & Pricing FAQ](https://auphonic.com/help)