# How to Vibe Code Your Own tl;dv (and Stop Paying for It)

> The AI Notetaker built for Team Collaboration

- Site: https://tldv.io
- Category: AI Meeting Assistant & Conversational Intelligence
- Verdict: **Serious undertaking** (35/100 vibecodeable)
- Estimated effort: 3-4 months of part-time development

## Verdict

Build a personal meeting search wrapper instead of a full clone; capturing live multi-platform video streams and orchestrating STT at scale requires heavy distributed engineering.

Attempting to build a full-scale clone of tl;dv for personal use is a serious undertaking. While putting a Next.js wrapper around a transcript summarizer is trivial, capturing audio/video streams from Zoom, Google Meet, and Microsoft Teams without bot restrictions, handling diarization, and managing vector embeddings across hours of conversations will consume dozens of frustrating hours. Paying $18/month for the real product is vastly more rational unless you are doing this purely to learn media pipelines.

### What you can't replicate

- The massive active user base and proprietary cross-company meeting insights
- Native zero-friction hook implementations across thousands of enterprise apps
- The institutional reliability of SOC 2 and GDPR compliance infrastructure

## What it does

An AI-powered meeting assistant and conversational intelligence platform that records, transcribes, and summarizes virtual meetings across Zoom, Google Meet, and Microsoft Teams.

### Core features

- Automated meeting recording and HD video/audio capture
- Speech-to-text transcription with speaker diarization in 30+ languages
- LLM-powered post-meeting summaries and custom prompt templates
- Cross-meeting semantic search and thematic intelligence
- CRM and project management auto-sync
- Model Context Protocol (MCP) server integration for developer tools

## The business

### Pricing

- Free Forever: $0 — For individuals and small teams wanting basic meeting summaries.
- Pro: $18/mo — For growing teams needing unlimited AI intelligence and search.

### Funding

$4.5M raised.
- Seed
Investors: K Fund, Seedcamp, Mustard Seed Maze, Shilling Capital Partners, another.vc

Founded 2020.
Team size: ~60.

## The hard parts

- Building reliable cross-platform screen and audio capture without intrusive bots
- Orchestrating low-latency speaker diarization and translation pipelines at scale
- Managing massive token context windows and vector RAG for months of meeting transcripts
- Maintaining thousands of fragile third-party integrations (HubSpot, Salesforce, Slack)

## How to vibe code tl;dv

### Prerequisites

- Node.js (Free): Required runtime for backend services and AI orchestration scripts.
- GitHub (Free): Version control and CI/CD pipelines.

### Recommended AI tools

- Claude Code: Best-in-class agentic coding tool for scaffolding full-stack features and handling complex multi-file refactors from the terminal.
- Cursor: Ideal AI-native editor for iterative frontend dashboard development and debugging UI components.

### Stack

- Frontend: Next.js
- Backend: Node.js
- Database: Neon
- Auth: better-auth
- Payments: Stripe
- Other: Vercel AI SDK, OpenAI API, Anthropic API

### Hosting

- Vercel (Hosting the Next.js frontend and serverless backend API routes.): $0-20/mo
- Neon (Serverless Postgres database with vector support for storing meeting transcripts and embeddings.): $0/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js project with TypeScript, configure Tailwind CSS, set up better-auth, and define Neon Postgres tables for users, meetings, transcripts, and embeddings.

```
Initialize a new Next.js 16 project with TypeScript and Tailwind CSS. Configure better-auth with email/password authentication connected to a Neon Postgres database using Drizzle ORM. Create database schemas for users, meetings (id, title, duration, createdAt), transcripts (id, meetingId, speaker, text, timestampStart, timestampEnd), and summaries (id, meetingId, content, actionItems). Ensure environment variables are structured correctly in a .env.example file. Implement a clean, responsive dashboard layout shell with a sidebar navigation for meetings, search, and settings.
```

2. **Audio Ingestion and Transcription Pipeline** — Build an audio upload endpoint and integrate OpenAI Whisper API to process uploaded meeting recordings, extracting timestamps and speaker text.

```
Build a robust audio upload API route in Next.js that accepts MP3, WAV, or M4A meeting recording files up to 500MB. Integrate the OpenAI Whisper API to transcribe the uploaded audio file with precise timestamps and word-level timing. Save the generated transcript chunks into the Neon database linked to the meeting record. Add a frontend upload modal with progress indicators and error handling for failed uploads or unsupported file formats.
```

3. **AI Summarization and Action Item Extraction** — Use the Vercel AI SDK and Anthropic API to generate structured meeting notes, summaries, and action items immediately after transcription.

```
Implement a server action using the Vercel AI SDK and Anthropic API to process completed transcripts. When a transcript is ready, send it to Claude with a system prompt designed to extract an executive summary, key discussion points, and a bulleted list of action items with assignees. Store the structured output in the summaries table and display it cleanly on the meeting detail view page with options to copy or export markdown.
```

4. **Cross-Meeting Semantic Search and RAG** — Set up pgvector in Neon to index meeting transcripts, enabling natural language search across all historical conversations.

```
Configure pgvector extension in the Neon Postgres database. Write a background job or server action that generates vector embeddings for meeting transcript chunks using OpenAI's embedding model. Implement a global semantic search interface in the Next.js frontend where users can query their entire meeting history in natural language, retrieving relevant meeting snippets with contextual citations and direct links to timestamps.
```

5. **MCP Server Implementation and Final Polish** — Expose a lightweight Model Context Protocol (MCP) server endpoint to stream meeting summaries directly into developer tools like Claude Code.

```
Build a Model Context Protocol (MCP) server module using Node.js that exposes endpoints to query and retrieve meeting summaries and action items on demand. Secure the MCP endpoints with API keys. Add comprehensive error handling, input validation across all routes, and polish the dashboard UI for seamless daily usage.
```

### Cost vs paying

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

- Domain name: $12 one-time
- OpenAI / Anthropic API starter credits: $20 one-time
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro hosting: $0-20/mo
- OpenAI Whisper & Anthropic API usage: ~$10/mo
- Total: ~$10-30/mo

- Paying for the SaaS instead: $18/mo (Pro Plan)
- Build time: 60-80 hours
- AI tool credits: $20 (Claude Code / Cursor)
- Break-even: Never (paying $18/mo is cheaper than 80 hours of dev time)

## Sources

- [tl;dv Official Website & Feature Pages](https://tldv.io)
- [PitchBook Company Profile: tl;dv](https://pitchbook.com)
- [Tracxn Company Profile: tl;dv](https://tracxn.com)