I've been working on my SEO content pipeline, and one of the things I wanted to automate was long-tail keyword research.

Once you have a seed keyword, the next step is figuring out what people are actually searching for, finding related queries, and identifying keywords worth exploring further.

Doing this manually across multiple keywords can get repetitive pretty quickly. You end up switching between different tools, collecting suggestions, organizing them, and trying to keep everything in one place.

So I decided to build an n8n workflow that automates this part of the research process and stores the results in Airtable.

Starting with a seed keyword

The workflow starts with a seed keyword that I've already stored in Airtable.

For example:

>n8n self-hosted requirements

When I trigger the workflow, it retrieves the corresponding Airtable record and checks its long-tail research status.

If the keyword needs to be processed, the workflow marks it as In Progress and starts researching keyword variations.

I wanted to keep this connected to Airtable so I could track which keywords have been processed instead of managing everything manually.

Finding related keywords with YepAPI

I didn't want to rely on a single source of keyword suggestions.

So I'm using YepAPI to collect keyword data through multiple research paths.

The workflow makes separate API requests for:

• Related keywords — finds keywords related to the original seed keyword.
• Keyword ideas — discovers additional keyword variations to explore.
• Autocomplete suggestions — collects search suggestions that can reveal more specific queries people might use.

Each API response is processed separately. The workflow splits the returned keyword lists into individual items and prepares them for the next stage.

This gives me multiple sets of keyword suggestions from the same seed keyword rather than relying on one list.

Getting keyword data

The autocomplete branch has an additional step.

After collecting the suggestions, the workflow sends them through another YepAPI request to retrieve keyword data.

This helps me bring the discovered keywords and their available SEO metrics into the same research pipeline.

The goal isn't just to collect a list of phrases. I also want the data organized so I can evaluate the keywords later.

Bringing everything together

Once the research is complete, the workflow combines the results from the different branches.

It standardizes the output, splits the responses into individual keyword items where needed, and prepares the records for Airtable.

In one execution, the workflow produced 26 output items:

• 7 related keyword items
• 6 keyword idea items
• 13 autocomplete-derived keyword items

These are the output counts from that execution, not necessarily 26 unique keywords. Deduplication is something worth checking when combining results from multiple sources.

Storing everything in Airtable

I use Airtable to keep the research organized.

Each keyword gets its own record, associated with the original seed keyword.

The table includes fields such as:

• Keyword
• Competition
• Search volume
• Keyword difficulty
• CPC

I can then review the results in one place instead of going back through individual API responses.

Once the records have been created, the workflow updates the original seed keyword's research status.

This also gives me a starting point for tracking the progress of each keyword through the pipeline.

What's next?

This is one part of a larger SEO content pipeline I'm building.

I don't want to jump straight from a seed keyword to generating an article. I'd rather break the process into smaller steps, with each stage producing structured data that the next stage can use.

The direction I'm working toward is:

Competitor Research → Seed Keywords → Long-tail Keywords → Subtopic Research → Content Planning → Article Writing

The long-tail keyword workflow is the next piece of that process.

I'm building this step by step, with n8n handling the automation and Airtable keeping the research organized.

Do you use separate tools for keyword discovery and metrics, or have you automated this part of your SEO workflow as well?

I’ve been working on SEO content for my own business, and honestly, I didn’t expect the process to be this difficult.

The obvious part is writing the article.

But before you can even get there, there’s a lot of work involved:

• Finding what people are actually searching for
• Researching competitors
• Finding the right keywords
• Planning what to write
• Researching the topic
• Writing the article
• Creating images
• Optimizing everything for SEO
• Publishing and maintaining the content

And doing this once isn’t the real problem.

The bottleneck is doing it consistently while keeping the quality high.

You can hire someone, use an agency, or subscribe to different SEO tools, but the cost can add up quickly. And if you’re a small business, paying for several tools just to keep your content pipeline running isn't always practical.

So I started thinking:

What if I just built my own SEO content pipeline?

Instead of trying to build everything at once, I’m building it piece by piece.

The first piece I’m working on is seed keyword research.

I start with a competitor URL and use YepAPI to pull the keywords that competitor is already ranking for.

From the results, I extract 10 seed keywords and store them individually in Airtable.

The idea is to use these as the starting point for the next stage: deeper long-tail keyword research.

So eventually, the pipeline should look something like:

Competitor Research → Seed Keywords → Long-tail Keywords → Content Research → Content Planning → Article Writing → Publishing

Still a long way to go, but the first piece is finally working.

Many founders spend months building their products but still struggle to identify who their ideal customers are, what problems they face, and how to reach them.

I wanted to automate that initial research process instead of manually browsing company websites, LinkedIn profiles, and compiling everything into documents.

So I built an AI-powered ICP Generator using n8n, Airtable, Gemini 2.5 Pro, and Perplexity.

The idea is simple: enter a company's website and LinkedIn profile in Airtable, click a button, and let the workflow research the company and generate a structured Ideal Customer Profile.

How the workflow works

Here's the basic flow:

Airtable → Webhook → Get Company Information → Check Research Status → AI Research Agent → Update Airtable

When someone clicks the Generate ICP button in Airtable, it triggers the n8n webhook.

The workflow retrieves the company's information, checks its research status, and marks the record as In Progress before passing the information to the AI research agent.

The AI research stack

The interesting part is how the AI agent is configured.

• Gemini 2.5 Pro: The main AI model responsible for analyzing company information and generating the ICP.
• Perplexity: Connected as a research tool to help gather additional company information.
• Memory: Provides contextual information to the AI agent.
• Structured Output Parser: Organizes the generated results into a predefined structure that can be saved in Airtable.
• Airtable: Stores the company information, research status, and generated ICP results.

Once the research is complete, the workflow updates the corresponding Airtable record with the generated results.

What does it actually generate?

For each company, the workflow generates a structured ICP analysis covering:

• Ideal Customer Profile: Target industries, company sizes, geographical locations, organizational structures, and decision-maker roles.
• Pain Points: The challenges and problems potential customers experience.
• Key Goals: What these customers want to achieve, improve, or automate.
• Current Solutions: How potential customers are currently addressing their problems, including existing platforms, tools, and manual processes.

The Airtable interface

I also built an Airtable interface so the entire process can be managed without opening n8n.

It includes a company information section with fields for the website, LinkedIn profile, product description, and a Generate ICP button. The generated research is displayed directly in the company's record.

But this is only one part of a larger SEO content generation and business research automation system.

The interface also includes sections for:

• Adding competitors
• Defining blog writing styles
• Generating seed keywords
• Researching long-tail keywords
• Reviewing keyword opportunities
• Generating SEO articles
• Reviewing and scheduling blog posts

The idea is to use the generated company research and ICP as the foundation for the subsequent marketing and content workflows.

Why I built this

I wanted to reduce the manual research involved in understanding a company's target audience and create a reusable workflow that could be triggered directly from an interface.

This could be useful for:

• Founders: Understanding their target customers before investing heavily in marketing.
• Marketing teams: Preparing initial customer research and developing content strategies.
• SEO professionals: Using customer insights to inform keyword research and article planning.
• Agencies: Automating parts of their initial client research and onboarding process.

The generated ICP is a starting point and still needs human review and validation, but it saves the effort of collecting and organizing the initial research manually.

One of the common challenges for founders is that they spend so much time building their products and services, but often struggle to clearly identify their Ideal Customer Profile (ICP).

Who are the right customers? What problems are they facing? What are their goals? How are they currently solving those problems?

Finding answers to these questions usually involves a lot of manual research, browsing company websites, checking LinkedIn profiles, and organizing everything into a structured document.

So I decided to automate this entire process using n8n, Airtable, Gemini 2.5 Pro, and Perplexity.

The idea was pretty straightforward.

Enter a company's website and LinkedIn profile in Airtable, click the Generate ICP button, and let the workflow research the company and generate a structured Ideal Customer Profile.

Here's how the workflow looks:

Airtable Interface → Webhook → Get Company Information → Check Research Status → AI Research Agent → Update Airtable Record

The interesting part is the AI research agent.

When someone clicks the Generate ICP button in Airtable, it triggers the n8n workflow through a webhook.

The workflow retrieves the company's information from Airtable, checks its research status, and marks it as in progress before starting the research.

Then the AI agent takes over.

I'm using Gemini 2.5 Pro as the main AI model, with Perplexity connected as a research tool to gather additional company information. The agent also has memory and a structured output parser to help organize the generated results.

The goal is to analyze the company's products, services, target market, and business information to generate a detailed ICP.

The generated output includes:

• Ideal Customer Profile: Target industries, company sizes, geographical locations, organizational structures, and decision-maker roles.
• Pain Points: The main challenges and problems potential customers face.
• Key Goals: What these customers want to achieve and improve in their businesses.
• Currently Solving Problems: How potential customers are currently addressing these challenges, including existing tools, platforms, and manual processes.

Once the research is complete, the workflow updates the corresponding Airtable record with the generated information.

I also built an Airtable interface to make the entire process easier to manage without having to interact directly with n8n.

The interface includes company information, product descriptions, generated ICP research, and other sections for the broader SEO content generation process.

The interesting thing is that this is just the starting point of a larger workflow.

The same interface also includes sections for adding competitors, defining blog styles, generating seed keywords, researching long-tail keywords, reviewing keywords, generating SEO articles, reviewing blog posts, and scheduling articles.

So the idea is to use the initial company research as a foundation for the entire SEO content generation process.

This could be useful for:

• Founders trying to understand their target customers.
• Startups researching their ideal customer profiles.
• Marketing teams preparing customer research.
• SEO professionals building content strategies around their target audience.
• Agencies conducting initial company and market research.

What I like about this setup is that you don't need to manually research every company and organize everything from scratch.

You can simply enter the company details, trigger the workflow, and let the AI handle the initial research and structuring.

Of course, the generated research still needs to be reviewed and validated, but it provides a useful starting point instead of a blank document.

That's basically the whole idea.

This is what I like about n8n: you can combine webhooks, Airtable, AI agents, research tools, and structured outputs to build an entire research workflow without having to develop a custom application from scratch.

I wanted to try something simple a WhatsApp AI assistant that doesn't forget the conversation after every message.

The idea was pretty straightforward.

When someone sends a message on WhatsApp, I want the AI to be able to look at the previous conversation, use that context to respond, and then save the new message for the next interaction.

So I ended up with this:

WhatsApp Message → Process Message → Get Memory → AI Assistant → Save Message → WhatsApp Reply

The interesting part is the memory.

Before sending the message to the AI, the workflow retrieves the user's previous conversation and prepares it as context for the assistant.

So instead of the AI seeing only:

>"What did we talk about yesterday?"

It can also have the previous conversation available to understand what the user is referring to.

The basic flow is: Receive the WhatsApp message → Process the message → Get the user's existing memory → Prepare the memory → Send everything to the AI assistant → Save the new message → Send the response back to WhatsApp

The AI assistant itself is pretty simple. It has the chat model, the memory, and a tool to save the conversation.

This could be useful for things like:

• Customer support
• Personal AI assistants
• Lead qualification
• Sales conversations
• Customer onboarding
• Business FAQs

That's basically the whole idea.

What I like about this setup is that you don't need to build a huge backend just to give an AI assistant some memory.

You can break the whole thing down into a few n8n nodes and connect the pieces together.

This is what I like about n8n you can take something that sounds complicated, like a WhatsApp AI assistant with memory, and turn it into a workflow you can actually see and understand.

What would you build with a WhatsApp AI assistant that could remember conversations?

I wanted to automate one of those small things that gets annoying pretty quickly sending a DM to people who comment on an Instagram post.

The idea was pretty simple.

If someone comments a specific keyword, I want n8n to recognize it and send them the relevant message and link automatically.

So I ended up building this:

New Comment → Find DM → Build DM → Send DM

The interesting part is that I'm not putting all the messages directly inside the workflow.

I'm keeping them in a Google Sheet instead.

Something like:

Post/Reel ID | Post Details | Short Message | Link | Comment Keyword

So let's say I make a post and tell people:

>Comment PAYMENT and I'll send you the link.

Someone comments PAYMENT.

n8n gets the comment, takes the Post/Reel ID and the comment keyword, and checks the sheet for a matching row.

If it finds one, it gets the message and link from that row, builds the DM, and sends it to the commenter.

If there's no matching keyword or post, it just stops there.

That's basically the whole thing.

What I like about this setup is that I don't have to touch the workflow every time I want to add a new comment trigger. I can just add another row to the sheet with the post ID, keyword, message, and link.

It's a pretty small automation, but it's a good example of what you can do with n8n.

And this is what makes n8n so useful you can save money and time by taking a small repetitive task and turning it into a simple automation.

What small repetitive task would you automate with n8n?

A complete Invoice & Payment Management workflow in n8n to handle invoices, payments, and refunds from end to end.

The goal was to keep the entire process inside one workflow while making sure each event is validated, processed safely, tracked, and returned to the application that triggered it.

Event Validation & Routing

Everything starts with a webhook that receives the incoming event.

The request is validated using API-key authentication before anything is processed. Invalid requests are rejected, while valid events are routed to the appropriate processing path.

This keeps the invoice, payment, and refund logic separated and makes the workflow easier to maintain.

Invoice Processing

When an invoice event is received, the workflow first checks whether the invoice already exists.

If it doesn't exist:

• The invoice data is stored in Google Sheets.
• PDFbro generates the invoice PDF.
• The generated PDF is uploaded to Google Drive.
• Resend sends the invoice directly to the customer.
• The results are merged.
• The invoice record is updated with the final processing status, PDF link, and email timestamp.

The duplicate check prevents the same invoice from being processed and sent multiple times.

Payment Processing

For payment events, the workflow first checks whether the payment has already been processed.

If it's a new payment:

• The payment transaction is stored.
• The related invoice is retrieved.
• The invoice balance is updated.
• The workflow checks whether the invoice has been fully paid.
• The appropriate payment email is sent.
• The payment status is updated.

This allows the workflow to handle both regular payment receipts and final payment confirmations.

Refund Processing

Refunds have their own dedicated processing path.

The workflow checks whether the refund has already been processed before creating a new transaction.

Once validated, it:

• Stores the refund transaction.
• Retrieves the related invoice.
• Updates the invoice's financial status.
• Sends the refund confirmation.
• Updates the refund status.

This ensures duplicate refund events don't result in duplicate processing or notifications.

Reliability & State Management

The main focus of this workflow was reliability and state management, rather than simply connecting a few services together.

Each event has its own processing path, duplicate events are checked before creating new records, and the relevant status is updated after processing.

This makes the workflow much closer to something you could actually run behind a real application.

Stack

• n8n — Workflow orchestration
• Google Sheets — Invoice, payment, and refund records
• PDFbro — Invoice PDF generation
• Google Drive — PDF storage
• Resend — Transactional email delivery
• Webhook — Application integration

A practical example of how n8n can be used as the orchestration layer for an entire business process, rather than just automating a single task.

To automate the whole invoice process instead of having separate steps for creating the invoice, saving it, sending it, and updating its status.

This workflow in n8n that takes invoice data from an application and handles everything automatically until the customer receives the invoice.

How it works

• Webhook — Receives the invoice data from the application and validates the request using an API key.
• Google Sheets — Stores the invoice information and keeps track of its current status.
• PDFbro — Takes the invoice data and generates the actual invoice PDF inside n8n using the n8n-nodes-pdfbro community node.
• Google Drive — Saves the generated PDF and uses the invoice number as the filename so it's easy to identify.
• Resend — Emails the generated invoice PDF directly to the customer as an attachment.
• Merge — Brings the results from the Google Drive and Resend branches back together.
• Update Invoice — Updates the invoice record with the final status, PDF URL, and the time the email was sent.
• Webhook Response — Sends the final result back to the application that started the workflow.

The main idea was to make the workflow responsible for the entire invoice lifecycle, rather than just automating one part of it.

Once the application sends the invoice data, everything else happens automatically in n8n.

Try it yourself: https://github.com/cuebicai/n8n-workflows/tree/main/automated-invoice-generation-and-delivery

A simple end-to-end invoice automation in n8n that handles the complete process from receiving invoice data to delivering the final invoice to the customer.

Workflow

Webhook → Google Sheets → PDFbro → Google Drive + Resend → Update Invoice → Webhook Response

What each part does

• Webhook — Receives the invoice data from the application with API-key authentication.
• Google Sheets — Stores the invoice details and tracks its status.
• PDFbro — Generates the invoice PDF directly inside the n8n workflow using the n8n-nodes-pdfbro community node.
• Google Drive — Stores the generated PDF with the invoice number as the filename.
• Resend — Sends the generated PDF to the customer's email as an attachment.
• Merge — Combines the results from the Drive and email branches.
• Update Invoice — Updates the invoice record with the final status, PDF URL, and email timestamp.
• Webhook Response — Returns the final result back to the application that triggered the workflow.

The goal was to keep each step focused on one responsibility while letting n8n handle the complete invoice lifecycle automatically.

I work with self-hosted n8n and wanted to get some actual numbers instead of assuming how a small instance would behave under sustained webhook traffic.

So I ran a simple stress test on a 2 vCPU / 2 GB RAM instance running n8n Regular Mode.

Test setup

The workflow was:

Webhook → Code → 2-second delay

For each incoming request, the Code node generated 1,000 items. The delay kept each execution active for roughly two seconds.

For the traffic, I sent:

• 100 webhook requests per minute
• 10 minutes continuously
• 1,000 requests total

I also watched the n8n executions and server metrics throughout the test.

Results

The instance handled the entire test without any failed requests.

• Requests: 1,000 / 1,000 successful
• Failures: 0
• CPU: ~1% idle → ~19% during the test
• RAM: ~46% idle → ~55% during the test
• Instance status: Healthy throughout
• After the test: CPU returned to around 1%

One thing I found useful was watching the executions rather than only looking at the server metrics. Multiple executions were active while the requests were coming in, but n8n continued completing them normally.

Once the traffic stopped, the instance returned toward its normal baseline.

Takeaway

This obviously isn't a benchmark for every n8n deployment the workflow, execution mode, database, network, and hardware will all change the result.

But for this particular setup, 1,000 webhook requests over 10 minutes with a 1,000 item workload per request was handled without failures.

I'm planning to repeat the test with different workloads and higher traffic rates to see where the behavior actually starts to change.

For those running self-hosted n8n: what kind of load have you tested, and what did you find was the first bottleneck CPU, RAM, database, or execution concurrency?

If you're running self-hosted n8n, the latest update adds some pretty interesting AI features.

You can now use the AI Assistant directly inside your n8n workspace to help build and modify workflows.

There’s also native support for AI Agents, where you can configure things like:

→ Channels → Tools → Skills → Sub-agents → Schedules → Models → Instructions

So you can build and configure AI-powered workflows without having to put everything together manually.

How do you enable it?

If you're managing your own n8n server, you'll need to configure the required AI environment variables and set up the n8n sandbox. You can also use Daytona for the sandbox environment.

Once everything is configured, restart/reload your n8n instance and the AI Assistant and AI Agents should become available inside your workspace.

If you don't want to deal with the server, Docker, SSH, environment variables, and sandbox configuration, there's another option.

Use Cuebic AI to make self-hosted n8n easier to manage.

The AI configuration can be handled directly from the instance settings:

Enable AI Assistant → Choose provider → Select model → Enable AI Agents → Apply

That's basically it.

After the changes are applied, you can go back to your n8n workspace and start using the new AI features.

I also made a short demo showing the complete process and how the AI Assistant can be used to modify an existing workflow.

If you're just getting started with self-hosted n8n, I thought this might be useful because the new AI features are definitely worth checking out.

If anyone has already enabled the AI Assistant or Agents on their self-hosted n8n instance, I'd also be interested to hear how it's working for you.

I've been playing around with the latest self-hosted update, and n8n now has both the AI Assistant and native AI Agents built directly into the workspace.

The Assistant can actually work with your workflows, instead of just answering questions.

You can ask it to create a workflow, modify an existing one, or help you build things using natural language.

And then there's the new AI Agent experience.

You can configure:

→ Channels → Tools → Skills → Sub-agents → Schedules → Models → Instructions

What I really like about this is that n8n is starting to feel less like you're manually wiring every single piece together and more like you're working alongside an AI that understands your workflow.

Still early, but this feels like a pretty interesting direction for n8n.

I made a short demo showing the whole thing in action.

Has anyone else tried this on their self-hosted n8n instance yet? I’d love to hear how it’s working for you and what your experience has been so far.

n8n execution test-1

You think you know how n8n executes a workflow?

Alright prove it.

Look at this workflow and comment which node executes first and what happens after that.

Don’t run it.

Just look at it and make your call.

Hints: The workflow starts from the Manual Trigger and then splits into two branches, and both branches eventually lead back toward the same If node. The top branch has DATA → Split Out, while the bottom branch has DATA1 → Network Call Wait.

Now think about the execution:

A. Top → Bottom: Start with the top branch, execute it left → right, finish it, then move to the bottom branch.

B. Bottom → Top: Start with the bottom branch, execute it left → right, finish it, then move to the top branch.

C. Switch between branches: Start with the top branch, execute until the If, switch to the bottom branch, then continue from there.

D. Both branches at the same time: n8n starts executing both branches in parallel.

Which one do you think it is?

I've been experimenting with a Telegram + n8n workflow for generating 3D anatomy visuals from a simple anatomy term.

The use case is straightforward: for medical study, anatomy education, or creating educational medical content, you may need visualizations of many different organs while keeping the images consistent in style.

Instead of manually writing a new prompt for every organ, the workflow separates the anatomical subject from the visual instructions.

For example, the user only sends:

kidney

The workflow then:

• validates that the input contains a single anatomical subject
• extracts the actual anatomy term
• combines it with a predefined Master Prompt
• sends that context to GPT-4.1
• generates a structured image-generation prompt
• sends the resulting prompt to Nano Banana 2
• waits for the generation to complete
• returns the final image through Telegram

The important part is the Master Prompt.

It contains the rules that should remain stable across generations:

• 3D medical rendering style
• anatomical accuracy requirements
• background and overall tone
• lighting
• camera position and composition
• rendering quality
• visual constraints and negative instructions

The anatomy itself is the variable.

So the workflow can receive:

kidney heart liver brain

without having to manually redesign the entire prompt for each one.

The architecture is essentially:

Telegram → validation → anatomy extraction → Master Prompt + subject → GPT-4.1 → Nano Banana 2 → Telegram

This also solves an issue I noticed when testing direct image generation.

If the raw anatomy term is sent straight to an image model, each generation can drift in lighting, composition, background, rendering style, and sometimes anatomical details.

Adding a dedicated prompt-construction step gives the image model a much more controlled specification before generation.

So the workflow isn't really about generating one anatomy image.

It's about creating a repeatable generation system where the subject can change while the visual specification remains controlled.

Built with:

• n8n
• Telegram Bot
• OpenAI GPT-4.1
• Nano Banana 2

The same approach could be useful for building consistent anatomy study materials, medical educational content, or a larger library of 3D anatomical visualizations without manually prompting every image.

Try it yourself:
https://github.com/cuebicai/n8n-workflows/tree/main/3D-anatomy-studio

I wanted to see how far I could push AI image generation with automation.

The idea is simple:

>Send an organ name like kidney or heart on Telegram and get back a realistic 3D anatomy visualization.

No manual prompt writing. The workflow handles the rest.

The Problem

AI image generation can be inconsistent between subjects.

A kidney might have one background and lighting style, while a heart gets a completely different look.

I wanted the anatomy to change while the visual identity stays consistent.

The Workflow

The automation:

• Validates that the user entered one anatomical subject
• Extracts the actual anatomy part
• Applies a structured Master Prompt
• Generates the final image prompt
• Sends it to Nano Banana 2
• Waits for generation
• Sends the finished image back to Telegram

The Master Prompt controls the fixed visual system:

• 3D medical rendering
• Background and tone
• Lighting
• Camera and composition
• Anatomical accuracy
• Rendering quality
• Negative constraints

So:

kidney → same visual style
heart  → same visual style
liver  → same visual style
brain  → same visual style

Only the subject changes.

Stack

• n8n
• Telegram
• OpenAI GPT-4.1
• Nano Banana 2

The interesting part for me is separating what to generate from how it should look. It makes the workflow reusable instead of relying on a completely new prompt every time.

Just send the anatomy part. The workflow handles the rest.

For the past few weeks, I've been pretty quiet not because I stopped building actually it's been the complete opposite.

I've been working on what I believe is one of the biggest updates to my project so far.

When I first started building it my goal was simple.

Make self-hosting n8n ridiculously easy.

No server setup.

No manual configuration.

No spending hours installing Docker, configuring SSL, setting up reverse proxies, or troubleshooting deployments.

Just launch your own instance and start building automations.

Over the past few months I've helped quite a few people get their own n8n instances running.

Seeing people actually use something I built has been one of the most rewarding parts of this journey.

But after watching more and more people deploy their instances, I kept coming back to one question.

What happens after deployment?

Because that's where the real challenge begins.

Once your workflows are running in production, deployment is no longer the hard part.

Keeping everything running reliably is.

You start asking questions like:

• Is my n8n instance still running?
• Are my workers healthy?
• Is PostgreSQL responding?
• Is Redis connected?
• Is my domain still reachable?
• Is my SSL certificate about to expire?
• Is CPU or RAM usage getting too high?
• Is disk space running out?
• Has bandwidth suddenly spiked?
• If something breaks, will I know before my users do?

If you've self-hosted n8n, you've probably been there.

You open Grafana.

Then Prometheus.

Then your VPS dashboard.

Then your logs.

Then Uptime Kuma.

Then SSH into the server.

You're constantly jumping between tools just to answer one simple question:

"Is everything okay?"

That made me realize something.

Deploying n8n is only the first step.

Running it in production is a completely different problem.

So for the past few weeks that's exactly what I've been building.

An integrated monitoring system that continuously checks every deployed instance.

Behind the scenes metrics are collected every few minutes, evaluated against monitoring rules, and turned into information that's actually useful instead of just showing raw metrics.

Right now it includes:

• 📈 Live CPU, RAM, storage, and bandwidth monitoring
• 📊 Historical performance charts
• 💚 Health checks for n8n, PostgreSQL, Redis, workers, and other services
• 🌐 Domain availability and SSL monitoring
• ⏱️ A 24-hour health timeline
• 🚨 Automatic incident detection
• 📧 Severity-based email notifications

Building this completely changed how I think about self-hosting.

Getting an application online is relatively easy.

Keeping it healthy every day is the part that takes the real work.

I'm genuinely curious how everyone here handles this today.

Do you use Prometheus and Grafana?

Uptime Kuma?

Netdata?

Custom scripts?

Or have you built your own monitoring setup around n8n?

I'd love to hear what your stack looks like and what has worked well for you.

I built an AI-powered 360° ghost mannequin t-shirt video generator using n8n.

Now whenever I send the front and back images of a t-shirt to my Telegram bot and select the body type, the automation automatically:

• downloads both t-shirt reference images
• analyzes the garment using AI vision
• identifies colors, graphics, typography, construction, and proportions
• builds a structured master specification for the t-shirt
• generates a specialized AI video prompt
• uses the front image as the authoritative front reference
• uses the back image as the authoritative back reference
• reconstructs realistic side and intermediate views
• generates a photorealistic 360° ghost mannequin rotation video
• monitors the video generation process automatically
• sends the finished video back to Telegram

The entire video generation process runs automatically from just two t-shirt images and a body type selection.

Built with:

• n8n
• Telegram Bot
• OpenAI GPT-4.1
• Seedance 2 mini via Kie AI
• ImgBB

The workflow was designed to reduce the work required to turn basic t-shirt product images into 360° e-commerce videos.

Instead of manually creating a 3D model, setting up a turntable animation, or writing a new video prompt for every t-shirt, the workflow first analyzes the garment and builds a structured master specification.

A second AI model then compiles that specification into a production-ready video prompt before generating the final 360° rotation.

This improves:

• front and back design preservation
• typography and artwork consistency
• garment proportion accuracy
• side-view reconstruction
• rotation consistency
• overall video realism

while reducing manual prompt writing, 3D modeling, video editing, and repetitive work.

Just send the front and back images of a t-shirt, select the body type, and receive a finished 360° ghost mannequin product video.

Try it yourself: https://github.com/cuebicai/n8n-workflows/tree/main/360-3d-t-shirt-mockup-ai-video-generator

Creating professional 360° apparel videos usually requires expensive 3D software, manual modeling, product photography, or complex CGI pipelines.

I wanted to see how far I could push AI.

The goal was simple:

>Upload the front and back images of a garment, choose the body type, and automatically generate a realistic 360° rotating ghost mannequin product video that is ready for e-commerce.

No manual prompt writing.

No video editing.

No 3D modeling.

Everything happens automatically.

The Problem

Creating high-quality apparel rotation videos is surprisingly difficult.

A typical workflow often involves:

• Photographing multiple angles of the garment
• Building or scanning a 3D model
• Cleaning the mesh
• Creating realistic cloth simulation
• Matching front and back artwork
• Rendering a turntable animation
• Editing and exporting the final video

Even with AI, most models struggle to:

• Preserve the front and back design accurately
• Generate believable side views
• Maintain garment proportions
• Keep artwork aligned during rotation
• Avoid flickering or temporal inconsistencies

For e-commerce, even small changes in print placement or garment shape can make the result unusable.

The Solution

I built an automated AI workflow using n8n that generates a photorealistic 360° ghost mannequin apparel video from only two reference images.

The user simply uploads:

• Front garment image
• Back garment image
• Body shape (Men's or Women's fit)

Everything else is handled automatically.

How the Workflow Works

The workflow consists of two AI pipelines running in parallel.

Pipeline 1 — Image Processing

The uploaded garment images are first analyzed using AI Vision.

The workflow automatically:

• Uploads and stores both reference images
• Extracts image metadata
• Detects garment characteristics
• Identifies the apparel type
• Understands colors, graphics, typography, construction, and proportions

This structured analysis becomes the foundation for the next stage.

Pipeline 2 — Video Prompt Generation

Instead of manually writing prompts, the workflow generates a structured master specification describing every aspect of the garment and scene.

The specification includes:

• Reference image interpretation
• Garment reconstruction rules
• Camera behavior
• Composition
• Lighting
• Background consistency
• Animation
• Rendering quality
• Preservation constraints
• Negative constraints

A second AI model then compiles this structured specification into a production-ready prompt optimized specifically for AI video generation.

This approach produces much more consistent results than writing prompts manually.

Video Generation

Once the prompt is generated, the workflow automatically prepares the API request and submits it for video generation.

The AI reconstructs one physically consistent 3D garment by using:

• The first image as the authoritative front
• The second image as the authoritative back

It then generates realistic intermediate views including:

• Left side
• Right side
• Shoulder profile
• Side seams
• Garment depth
• Three-quarter angles

Finally, it creates a smooth 360° rotating ghost mannequin video while preserving the garment's structure and artwork.

Automation Features

The workflow also handles the entire generation lifecycle automatically.

It:

• Uploads reference images
• Builds the master specification
• Generates the optimized AI prompt
• Starts video generation
• Polls the generation status
• Retrieves the completed video
• Sends the finished result directly to Telegram

The user never needs to monitor the generation manually.

Tech Stack

• n8n
• Telegram Bot
• OpenAI GPT-4.1
• Seedance 2 mini (via Kie AI)
• ImgBB
• Structured AI Prompt Compiler

Workflow Architecture

Telegram Form
        │
        ▼
Upload Front & Back Images
        │
        ▼
Extract Image Metadata
        │
        ▼
AI Garment Analysis
        │
        ├────────────────────────────┐
        │                            │
        ▼                            ▼
Image Generation              Master Specification
                                      │
                                      ▼
                           AI Prompt Compiler
                                      │
                                      ▼
                       Seedance 2 mini Video Generation
                                      │
                                      ▼
                            Status Monitoring
                                      │
                                      ▼
                           Telegram Video Delivery

Why I Built It

I wanted a workflow that could produce consistent apparel product videos without relying on handcrafted prompts for every garment.

By separating the process into structured analysis, specification generation, prompt compilation, and video rendering, the workflow becomes reusable for different garments while maintaining consistent output quality.

It also makes experimenting with different AI video models much easier, since only the final prompt compiler needs to change.

Current Result

The workflow can now automatically generate:

• AI garment analysis
• Structured master specification
• Production-ready AI video prompt
• Photorealistic 360° ghost mannequin rotation
• Commercial-style product presentation
• Automatic Telegram delivery

The entire process runs end-to-end with minimal user input just two reference images and a body type selection.

New Feature: One-Click n8n Version Updates & Rollbacks

One of the most requested improvements for self-hosted n8n is making upgrades less painful.

If you've ever updated n8n manually, you know the process usually involves SSH access, Docker commands, restarting containers, and hoping everything works as expected. And if a new release introduces a compatibility issue, rolling back can be just as time-consuming.

To make that easier, I've added one-click n8n version updates and rollbacks to Cuebic AI.

What you can do

• Upgrade to the latest supported n8n version with a single click
• Roll back to a previous version whenever needed
• Switch n8n versions without redeploying your instance
• Keep your workflows, credentials, and configuration intact throughout the process

The goal is simple: updating your self-hosted n8n instance should be as easy as deploying it.

Why this matters

Updating regularly gives you access to:

• New n8n features
• Performance improvements
• Bug fixes
• Security updates

And when an update doesn't play nicely with an existing workflow, having a rollback option makes it much safer to upgrade without worrying about downtime.

Feedback welcome

If you self-host n8n, I'd love to hear how you're currently handling version updates.

• What's your current update process?
• Have you ever had to roll back after an upgrade?
• Are there any safeguards or version management features you'd like to see?

Always interested in hearing feedback from the n8n community.

I've been experimenting with a workflow that automatically turns a t-shirt design into a production-ready apparel mockup.

Instead of manually opening a mockup generator, positioning the artwork, adjusting placement, and exporting product images, I send a design image to a Telegram bot and the workflow handles the rest automatically.

The workflow:

• analyzes the artwork using AI vision
• extracts typography, graphics, colors, layout, and design characteristics
• generates a specialized apparel mockup prompt
• creates a premium 3D t-shirt mockup
• preserves the original artwork with high fidelity
• applies the design as a realistic garment print
• monitors the generation process automatically
• sends the finished mockup back to Telegram

Built with:

• n8n
• Telegram Bot
• OpenAI 4.1
• Nano Banana 2
• ImgBB

One thing I noticed while testing:

Generating apparel mockups directly from a design image often produces distorted artwork, inaccurate colors, or inconsistent print placement.

The workflow performs much better when it first analyzes the uploaded design and generates a structured apparel-rendering prompt before creating the final mockup.

This improves:

• artwork fidelity
• typography preservation
• color accuracy
• print placement quality
• garment realism
• overall mockup consistency

For those selling apparel online, designing merch, or running print-on-demand stores:

Do you think AI-generated mockups could eventually replace graphic designers and traditional editing software for creating apparel product images?

Try it yourself:
https://github.com/cuebicai/n8n-workflows/tree/main/3D-t-shirt-mockup-generator