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

> Edit Your Next Podcast Episode in 20 Minutes

- Site: https://alitu.com
- Category: Audio & Podcast Production SaaS
- Platforms: Web app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 4-6 weeks of dedicated development and pipeline debugging

## Verdict

Build a subset with a Next.js web app and OpenAI Whisper, but expect severe friction around browser-based audio recording and server-side DSP pipelines.

While the CRUD dashboard, RSS feed generator, and text-based editor UI are straightforward for an AI coding agent to scaffold, implementing reliable in-browser multi-track recording with `MediaRecorder` and orchestrating heavy FFmpeg audio processing pipelines without timing out serverless functions will require significant manual debugging and architectural work.

### What you can't replicate

- The exact proprietary DSP tuning and acoustic engineering presets refined over years of user feedback
- The integrated podcast distribution ecosystem and direct platform partnerships

## What it does

An all-in-one SaaS platform built to automate and simplify podcast creation, recording, editing, hosting, and distribution for solo creators and indie podcasters.

### Core features

- Browser-based multi-track audio/video recording with local chunked backups
- Automated audio DSP (noise reduction, hum removal, loudness normalization)
- Interactive transcript editor linked to waveform playback
- Podcast RSS generation and automatic distribution to Apple Podcasts/Spotify
- Free podcast website hosting with analytics dashboard
- AI transcription and automated show notes generation

## The business

### Pricing

- Audio Plan: $38/mo — Covers solo and guest audio recording, automated clean-up, text-based/waveform editing, and hosting.
- Video Plan: $79/mo — Adds 1080p video recording studios and video publishing workflows.

Founded 2018.
Team size: 5 to 15 employees.

## The hard parts

- In-browser multi-track recording without audio drift or data loss during network blips
- Robust server-side audio DSP pipelines (FFmpeg / loudness standardization chains) running reliably at scale
- Reliable RSS XML generation complying with Apple/Spotify strict podcast specifications
- Low-latency streaming of large audio/video media files via byte-range requests

## How to vibe code Alitu

### Prerequisites

- Node.js (Free): Required runtime for running Next.js frontend and backend API routes.
- GitHub (Free): Version control and repository hosting to deploy via cloud providers.
- OpenAI API Key (Pay-as-you-go): Provides Whisper and GPT models for transcription and show note generation.

### Recommended AI tools

- Claude Code: Agentic terminal coding tool capable of scaffolding the full-stack Next.js architecture, writing complex API routes, and debugging client-side media recorder state.
- Cursor: Ideal AI-native editor for refining the complex transcript-to-waveform synchronization UI and interactive timeline components.

### Stack

- Frontend: Next.js with React and Tailwind CSS
- Backend: Next.js Server Actions and API Routes
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: None (Personal-use clone)
- Other: OpenAI Whisper API for transcription, FFmpeg for server-side audio processing, Cloudflare R2 for media storage

### Hosting

- Cloudflare (Hosting Next.js frontend and static asset storage via R2 buckets.): $0-5/mo
- Fly.io (Running long-lived background container workers equipped with FFmpeg for audio processing.): $3-5/mo

### Build guide

1. **Project Scaffolding & Database Schema** — Initialize the Next.js project with Tailwind CSS, configure Turso SQLite with Drizzle ORM, and set up better-auth for single-user or personal authentication.

```
Initialize a new Next.js project with Tailwind CSS, TypeScript, and App Router. Set up Drizzle ORM with a Turso SQLite database connection. Define the database schema for podcasts, episodes, tracks, and transcripts with appropriate foreign key relationships and timestamps. Implement better-auth configured for email/password authentication. Create a clean dashboard layout shell with a sidebar navigation for 'Shows', 'Episodes', 'Recording Studio', and 'Hosting'.
```

2. **In-Browser Audio Recording Studio** — Build the recording interface using the browser MediaRecorder API with local chunking and background upload safety.

```
Create a browser recording studio page in Next.js using the Web Audio and MediaRecorder APIs. Support recording solo audio with live microphone waveform visualizers using Canvas. Implement local IndexedDB chunking to store recorded audio blocks client-side in real-time, preventing data loss during network interruptions. Provide controls for Start, Pause, Stop, and a final upload mechanism that streams the recorded Blob to Cloudflare R2 via presigned URLs.
```

3. **Server-Side Audio Processing Pipeline** — Create an asynchronous processing worker that normalizes audio, removes background hum, and prepares master MP3 files using FFmpeg.

```
Build a background job worker using Node.js and Fluent-FFmpeg that triggers upon episode upload. Implement an audio engineering pipeline that applies high-pass filtering (hum removal), noise suppression filters, and standardizes audio loudness to -16 LUFS (podcast standards) with dynamic range compression. Export the processed audio into a standardized MP3 file, calculate its duration and file size, and store the output back in cloud storage.
```

4. **AI Transcription & Show Notes Generation** — Integrate the OpenAI Whisper API to generate time-stamped transcripts and use an LLM to generate formatted show notes.

```
Implement an API route that sends processed episode audio files to the OpenAI Whisper API to receive a time-stamped JSON transcript. Parse the transcript segments and store them in the database linked to the episode ID. Create an additional LLM integration step using the transcript text to automatically generate structured show notes, key bullet points, and social media summaries.
```

5. **Text-Based Transcript Editor** — Build an interactive editing interface where users can delete transcript segments to slice and edit the underlying audio timeline.

```
Create an interactive React component for text-based audio editing. Display the Whisper transcript with editable text blocks and clickable timestamps. When a user deletes a sentence or paragraph from the text view, calculate the corresponding audio time range start and end points. Send these cut instructions to the backend FFmpeg processor to splice the master audio file accordingly and regenerate the waveform preview.
```

6. **Podcast RSS Feed & Web Hosting** — Generate standard RSS XML feeds for podcast directory distribution and build a simple public podcast website template.

```
Build an RSS feed generator endpoint adhering strictly to Apple Podcasts and Spotify RSS specifications (including iTunes namespace tags, enclosure URLs, duration, explicit tags, and pubDate). Create a public podcast landing page and episode directory within the app that renders published episodes with an embedded HTML5 audio player, show notes, and subscription links.
```

### Cost vs paying

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

- Domain name (optional): $12
- AI coding credits: $20
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Cloudflare & Fly.io hosting: $8/mo
- OpenAI API usage (transcription & notes): ~$5/mo
- Total: ~$13/mo

- Paying for the SaaS instead: $38/mo
- Build time: 40-60 hours
- AI tool credits: $20
- Break-even: 1 month

## Sources

- [Alitu Official Website & Pricing](https://alitu.com)
- [Startups for the Rest of Us - Episode 531: Colin Gray Interview](https://www.robwalling.com)