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

> Turn text into videos with AI voices

- Site: https://fliki.ai
- Category: AI Video Generation & Content Creation
- Platforms: Web app
- Verdict: **Serious undertaking** (45/100 vibecodeable)
- Estimated effort: 3-4 weeks of focused development

## Verdict

You can build a functional single-user wrapper for text-to-video generation, but the asynchronous background video rendering pipeline and multi-API orchestration require significant engineering effort.

Fliki is fundamentally a complex middleware aggregator that glues together disparate third-party AI models (ElevenLabs, OpenAI, Kling, Google Veo), slices text into sentence scenes, fetches stock media, and stitches them into a rendered video. While you can easily set up a Next.js UI that calls these APIs via server actions, building a reliable asynchronous job queue that handles failed generations, precise subtitle timing synchronization, and video assembly will test your backend architecture skills. Since Fliki's individual paid tiers cost around $28/mo, paying for the service is far cheaper than building a production-grade clone, unless you are building it purely to master video rendering pipelines.

### What you can't replicate

- The massive proprietary library of aggregated pre-licensed stock assets and enterprise supplier volume discounts
- The exact fine-tuned prompt engineering and latency optimization layers built over 5 years of operations

## What it does

An AI-powered text-to-video and text-to-speech platform that converts text prompts, scripts, blog posts, or PowerPoint presentations into fully realized videos complete with voiceovers, background music, stock or AI visuals, and burn-in captions.

### Core features

- Multi-format input parsing (idea, script, blog URL, PPT/PDF upload)
- Sentence-level text segmentation and script drafting engine
- Multi-engine text-to-speech (TTS) orchestration and voice cloning
- Stock media asset search (images, video clips, music) and auto-matching
- AI video model pipeline (integration with Veo, Kling, Flux, etc.)
- Burn-in subtitle generation with customizable fonts, colors, and timing
- Background music ducking and audio mixing
- Multi-resolution video timeline rendering and export engine

## The business

### Pricing

- Free: Free
- Standard: $28/mo
- Premium: $88/mo

Founded 2021.
Team size: 13-20.

## The hard parts

- Orchestrating and error-handling asynchronous third-party AI video and TTS generation APIs at scale
- Building a responsive web timeline editor that syncs precise sentence audio boundaries with visual frames
- Managing background rendering queues without locking up the client UI
- Handling credit/token metering quotas tied to consumption-heavy media rendering

## How to vibe code Fliki

### Prerequisites

- Node.js (free): Required for running the Next.js full-stack development environment.
- GitHub (free): Source code control and deployment pipeline integration.
- OpenAI API Key (pay-as-you-go): Required for text script generation and AI model prompts.
- ElevenLabs API Key (pay-as-you-go): Required for lifelike text-to-speech audio generation.

### Recommended AI tools

- Claude Code: Ideal terminal agent for scaffolding complex multi-file Next.js apps, setting up API clients, and debugging asynchronous job queues.
- Cursor: Excellent for fine-tuning the complex React timeline editor UI and CSS styling.

### Stack

- Frontend: Next.js with Tailwind CSS and shadcn/ui
- Backend: Next.js Server Actions & API Routes with Inngest for background rendering workflows
- Database: Turso (SQLite at the edge)
- Auth: better-auth
- Payments: Stripe
- Other: FFmpeg (via server execution / fluent-ffmpeg for video assembly), Resend for transactional emails

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints): $0-20/mo
- Fly.io (Running the Docker container with FFmpeg and heavy background video rendering worker processes): $5-10/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize a Next.js project with Tailwind CSS, shadcn/ui, Turso for database storage, and better-auth for authentication.

```
Create a new Next.js 16 project with TypeScript, Tailwind CSS v4, and App Router. Configure Drizzle ORM to connect to Turso (SQLite). Implement a schema for users, projects (storing title, script text, aspect ratio, status), and scenes (storing scene text, audio URL, visual asset URL, duration, subtitle markers). Set up better-auth for secure credential and Google OAuth sign-in. Ensure all configuration files are fully written out and ready to run.
```

2. **Script Ingestion and Scene Segmentation Engine** — Build the text input parser that takes scripts, blog URLs, or ideas, and breaks them into sentence-level scenes.

```
Create a React component dashboard where users can input a script, paste a blog URL, or type a one-line prompt. Implement a server action that calls OpenAI to convert raw inputs into structured JSON array scenes (each containing a sentence of text, suggested visual description, and keyword tags). Display these scenes in an interactive script editor UI using shadcn/ui components, allowing users to edit text, reorder scenes, or delete segments.
```

3. **Text-to-Speech Audio Generation Integration** — Integrate ElevenLabs API to generate realistic voiceovers for each scene and calculate duration markers.

```
Build an API route and server utility that integrates with the ElevenLabs API. When a user finalizes their scenes, loop through each scene's text, send it to ElevenLabs with a selected voice ID, and save the resulting audio file to cloud storage (or local tmp storage). Retrieve and store the exact audio duration for each scene to drive timeline synchronization. Display audio playback controls next to each scene in the editor.
```

4. **Visual Asset Pairing and Stock Media Search** — Implement stock media asset search and image generation prompts to assign background visuals to each scene.

```
Integrate Unsplash and Pexels APIs (or stock fallback placeholders) into the project. For each scene, use the scene's keyword tags to fetch matching background stock images or video clips. Provide a media picker modal in the UI allowing users to search and swap background visuals for any scene with a single click.
```

5. **Asynchronous Video Rendering Pipeline with FFmpeg** — Build a background worker pipeline that combines audio tracks, background visuals, and burn-in subtitles into a final MP4 video.

```
Create a robust background worker service using FFmpeg (via fluent-ffmpeg in a Node.js container or Fly.io worker). The worker must take a project's compiled scenes (audio files + background images/clips + subtitle text), generate subtitle SRT files, apply audio ducking, stitch the scenes together with smooth transitions, and render a final 1080p MP4 export in the requested aspect ratio (16:9, 9:16, 1:1). Handle progress updates and save the rendered video URL to the database.
```

6. **Video Player, Timeline Preview, and Export Dashboard** — Build the final export dashboard and video player interface where users can preview rendered videos and download or share them.

```
Build a video preview and management dashboard in Next.js. Display rendering job status in real time (polling or WebSockets). Once a video finishes rendering, embed a custom HTML5 video player allowing users to preview the final output, adjust export settings, download the MP4 file locally, or copy a public share link.
```

### Cost vs paying

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

- AI coding tool subscription: $20
- Total: $20 one-time

**Ongoing costs (monthly):**

- Vercel / Fly.io Hosting: $10/mo
- ElevenLabs & OpenAI API usage: $15/mo
- Total: ~$25/mo

- Paying for the SaaS instead: $28/mo (Standard Plan)
- Build time: 45-60 hours
- AI tool credits: $20 (Claude Pro / Cursor)
- Break-even: Not a financial arbitrage (built for learning)

## Sources

- [Fliki Official Website](https://fliki.ai)
- [GetLatka - Fliki Revenue and Company Profile Snapshot](https://getlatka.com/companies/fliki)
- [Tracxn - Fliki Company Profile & Funding Status](https://tracxn.com)
- [Max Productive AI - Fliki Review and Technical Architecture Breakdown](https://maxproductive.ai)