DEV Community: SuryaElz

Stop writing invisible "Glue Code": Why I use N8N to orchestrate Python Microservices

SuryaElz — Tue, 06 Jan 2026 11:20:30 +0000

When building YouClip (an AI video clipper), I had heavy Python scripts for FFmpeg and AI analysis running in Docker containers.

The traditional way to connect them to my Next.js frontend would be writing a complex message queue system (using Redis/Celery/BullMQ).

The Problem

Writing queue logic is boring. Debugging stuck jobs involves digging through obscure terminal logs. You can't "see" where the process failed easily.

The Solution: N8N as a "Control Plane"

I didn't replace the heavy code—the video processing still happens in optimized Python scripts. But I replaced the "Glue Code" (retries, state management, error handling) with self-hosted N8N workflows.

Why this architecture wins:

Visual Debugging: I can see exactly which step a video generation failed at (e.g., did transcription fail or rendering?).
Modularity: I can swap out Gemini for OpenAI just by changing one node, without touching the Python worker code.
Built-in Retries: N8N handles exponential backoffs automatically.

It feels like cheating, but it makes the architecture incredibly robust and keeps my Next.js backend clean.

The Source Code

I recently landed a full-time AI Engineering role, so I packaged this entire architecture (Next.js + N8N + Python) into a starter kit for others to use.

You can grab the architecture breakdown and code here:
👉 https://github.com/suryaelidanto/Opus-Pro-Clone-AI-Video-Clipper-SaaS

How I built an Opus Pro clone for $5/mo using Next.js, N8N, and Python (Microservices Architecture)

SuryaElz — Tue, 06 Jan 2026 02:40:26 +0000

I spent the last 8 months building YouClip, an AI video clipper designed to turn long podcasts into viral shorts automatically.

Most competitors burn cash on expensive GPU instances for video rendering. I wanted to prove you could build a scalable engine on dirt-cheap CPU instances.

The Result

I managed to get the entire orchestration (FFmpeg + AI Analysis) running for under $15/month in total infrastructure costs.

Compute: $5/mo (Standard CPU VPS). No GPUs.
AI: ~$5/mo (Gemini Flash/OpenRouter).
Proxies: ~$3.50/mo.

The Architecture (The Secret Sauce)

I decoupled the monolith into 7 distinct microservices orchestrated by Docker & N8N.

Frontend: Next.js 16 (App Router) for the UI.
Brain: N8N handles the state, error handling, and directing traffic between services.
Worker: Python FastAPI specifically optimized for CPU-based FFmpeg processing (auto-reframe, face tracking).
Intelligence: Gemini Flash for scoring the "virality" of clips.

The Challenge: FFmpeg on CPU

The hardest part was preventing the API gateway from timing out while FFmpeg was crunching 1GB video files. I solved this by using N8N webhooks to handle asynchronous callbacks. The Next.js frontend polls the status, while the Python worker churns through the video in the background.

Open Sourcing the Architecture

I recently landed a new full-time role as an AI Engineer, so I won't have time to market this SaaS actively.

Instead of letting the code rot on my hard drive, I decided to package the entire engine and source code for other devs who want to skip the 8 months of R&D I went through.

You can grab the full architecture and starter kit here:
👉 View the Repository on GitHub

I also documented how to handle the N8N <-> Python handoff in the README.

Happy coding!

How I built an AI Video Clipper with Next.js, N8N, and Python (Microservices Architecture)

SuryaElz — Sun, 04 Jan 2026 14:15:00 +0000

I spent the last 8 months building YouClip, an AI video repurposing SaaS that turns long YouTube videos into viral shorts using AI scoring and face tracking.

It handles real users in production.

The Architecture

The system uses a Microservices approach orchestrated by Docker Compose:

Platform: Next.js 16 (Frontend & Auth)
N8N: The brain. It manages the workflow logic.
YT-Downloader: A Python service to handle downloads.
FFmpeg-Builder: FastAPI service for auto-reframing (9:16) and burning subtitles.
Control-Plane: Node.js service for state management using Redis.

Why Microservices?

Video processing is heavy. By separating the Downloader and Renderer into different containers, I can scale them independently without crashing the main Next.js app.

The Outcome

I recently landed a full-time AI Engineering role, so I'm shifting my focus away from this SaaS.

Instead of letting the code gather dust, I packaged the Entire Source Code + Docker Setup as a Starter Kit.

If you want to build an Opus Pro clone or study this architecture, you can grab the code here:

👉 https://purchase.youclip.id/

It includes all 7 microservices, N8N workflows, and a setup guide.

Let me know if you have questions!