Automate Anything with Make.com, Here’s How
Based on David Ondrej's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.
Use Airtable as the state tracker for multi-stage AI pipelines: store movie definitions, scene prompts, aspect ratios, and returned task/image/video IDs.
Briefing
A practical, credit-aware workflow for turning a single text prompt into a complete faceless “AI video” pipeline is the centerpiece: Midjourney generates scene images, Go API orchestrates Midjourney calls without direct APIs, Luma Labs animates the upscaled frames, 11Labs adds voice, and a video-editing layer stitches four scenes into a final output with captions. The payoff is less about one-off creativity and more about building a repeatable automation that can scale across prompts while keeping quality under control.
Steven G Pope walks through a Make.com setup built around Airtable as the control plane. A “movies” table defines a project, then scenes are added with prompts and aspect ratios. When a user selects a scene and triggers a checkbox, Make.com sends an API request via Go API to Midjourney. Because Midjourney takes time to render, the workflow relies on webhooks: once the render finishes, Go API hits a webhook, Make.com retrieves the resulting task/image ID, and Airtable updates the record so the generated images appear in the interface.
From there, the pipeline selects one of the generated images for upscaling. Another Midjourney API call produces the higher-resolution frame, again using task IDs and webhooks to return results into Airtable. Only after the upscaled image is ready does the workflow move to video generation: it creates a “video prompt” describing motion and camera behavior (for example, animating cars driving on the Los Angeles freeway, clouds drifting, or acting “like you’re a drone” flying forward). Go API also integrates with Luma Labs, enabling the same orchestration approach even though neither Midjourney nor Luma Labs is presented as a straightforward API-first product.
Video generation introduces a more complex wait strategy. Instead of sleeping for a fixed long interval, Make.com uses a repeater loop that checks status every 60 seconds, then exits the loop once the job is complete and writes the finished video back to Airtable. The automation deliberately avoids fully hands-off generation for every step because video rendering can burn credits quickly; Pope favors approving or curating key outputs to protect quality and cost.
After the four scenes are produced, a separate editing automation assembles them into a single deliverable. The workflow uses an API-based editing platform powered by FFmpeg to stitch scene clips together. In a related example, the system also generates audio and captions automatically—using 11Labs for AI voice—so the final product can be formatted for short-form distribution.
Beyond the build, the conversation turns to strategy: automation shouldn’t chase perfection in one model or one tool. The most durable advantage is designing workflows that benefit from model improvements—so when Midjourney, Luma Labs, or 11Labs updates, the automation can swap in better outputs without rebuilding from scratch. The discussion also emphasizes systematic debugging (change one variable at a time) and using AI tools to accelerate development when no-code platforms hit limits, such as Make.com’s file-size constraints for moving large video assets. Finally, the pipeline is positioned as a foundation for monetization through templates plus coaching/consulting—helping businesses apply AI practically rather than chasing flashy experiments that don’t hold up in production.
Cornell Notes
The workflow described turns a text prompt into a multi-scene faceless AI video by chaining Midjourney image generation, Midjourney upscaling, Luma Labs animation, and 11Labs voice—then assembling everything into one final video with captions. Make.com acts as the orchestrator, while Airtable stores movie and scene definitions and tracks task IDs as jobs complete. Go API bridges the gap by enabling Midjourney and Luma Labs calls through API-like requests plus webhook callbacks, even though direct APIs aren’t available in the usual way. The build uses status-check loops to avoid long idle waits and deliberately limits full automation to control credit costs. The broader lesson: design automations that improve as underlying models improve, and treat iteration and debugging as part of the process.
How does the pipeline coordinate Midjourney renders when Midjourney doesn’t provide a simple “wait for result” API flow?
Why does the build separate image generation, upscaling, and video prompting instead of going straight from prompt to animation?
What credit-cost problem does the automation try to avoid, and how?
How does Make.com handle variable Luma Labs render times without wasting time?
What role does Airtable play beyond storing prompts?
Why is the “model-agnostic” mindset treated as a durability strategy?
Review Questions
- If you had to redesign this automation from scratch, which components would you treat as the “control plane” (state tracking) versus the “execution plane” (API calls and webhooks), and why?
- Where in the pipeline would you insert quality gates to control credit usage, and what signals (e.g., which Airtable fields) would you use to decide?
- How would you modify the status-check loop if render times became highly variable (e.g., sometimes 30 seconds, sometimes 30 minutes) while still avoiding excessive polling costs?
Key Points
- 1
Use Airtable as the state tracker for multi-stage AI pipelines: store movie definitions, scene prompts, aspect ratios, and returned task/image/video IDs.
- 2
Bridge non-API-first tools with an orchestration layer (Go API) plus webhooks so Make.com can resume exactly when renders finish.
- 3
Split the workflow into stages—image generation, upscaling, then video prompting—so video motion prompts can be tuned after seeing the visual output.
- 4
Control credit burn by adding approval steps (human-in-the-loop) for the most expensive stages like video generation and upscaling.
- 5
Use Make.com repeater loops with frequent status checks (e.g., every 60 seconds) instead of long fixed waits to reduce idle time.
- 6
As models update, design the automation so it benefits immediately from better Midjourney/Luma Labs/11Labs outputs without rebuilding the entire system.
- 7
Treat systematic debugging as a core skill: change one variable at a time and use AI tools to diagnose errors quickly when integrations fail.