n8n Tutorial

  • Loading...

n8n tutorial - Lesson 23: Production-Ready n8n Workflows: Hardening and Scheduling

On
n8n tutorial - Lesson 23: Production-Ready n8n Workflows: Hardening and Scheduling

Hi everyone, in this post we're covering how to harden a multi-workflow n8n automation into a true n8n production workflow — adding error handling, scheduling, and live alerting. This is Session 23 of the n8n Workflow Automation Tutorial series, and it's where your Content Factory stops being a manual prototype and starts running reliably on its own.

How to do:

Step 1 — Verify Initial Workflow States

Before making any changes, confirm the starting state of all four workflows to avoid activating them in the wrong order.
  1. Open your n8n dashboard and check that T6-Content-Factory-Dispatch, T6-Content-Child-Blog, and T6-Content-Child-YouTube are all Inactive.
  2. Confirm that T6-B1-Error-Handler is already Active. This is the baseline — the error handler must be live before you test anything.

Note — If any child workflow is Active before you configure its error settings, deactivate it now. You want a clean slate before touching the node settings.

Step 2 — Set "On Error = Continue (using error output)" on Execute Sub-workflow Nodes

This setting prevents a child workflow failure from silently killing the entire parent run — it routes the error into a visible output instead.
  1. Open T6-Content-Factory-Dispatch (the parent workflow) in the editor.
  2. Click the Execute Sub-workflow node that calls T6-Content-Child-Blog.
  3. Go to Settings inside that node and find the On Error dropdown. Set it to Continue (using error output).
  4. Repeat the same three actions for the Execute Sub-workflow node that calls T6-Content-Child-YouTube.
  5. Save the parent workflow after both nodes are configured.

Tip — After selecting Continue (using error output), you will notice a new red output pin appears on the Execute Sub-workflow node. This is expected behavior — it is the error branch. You do not need to connect it to anything right now; it simply means errors will no longer crash the execution silently.

Step 3 — Replace Manual Trigger with a Schedule Trigger

Swapping out the Manual Trigger for a Schedule Trigger is what makes this an automated n8n production workflow instead of a tool you run by hand.
  1. Inside T6-Content-Factory-Dispatch, click the existing Manual Trigger node and delete it.
  2. Add a new Schedule Trigger node from the node panel.
  3. Configure it with the following values:
    • Trigger Interval: Days
    • Hour: 8
    • Minute: 0
  4. Connect the output of Schedule Trigger to the first node in your existing flow (the same connection the Manual Trigger had).
  5. Save the workflow.

Step 4 — Attach the Error Workflow to All Three Workflows

Assigning T6-B1-Error-Handler as the error workflow for each of the three workflows ensures that any unhandled failure fires a Telegram alert automatically.
  1. Open T6-Content-Factory-Dispatch and go to Workflow Settings (the gear icon or top menu).
  2. Find the Error Workflow field and select T6-B1-Error-Handler from the dropdown. Save.
  3. Open T6-Content-Child-Blog, go to Workflow Settings, set Error Workflow to T6-B1-Error-Handler. Save.
  4. Open T6-Content-Child-YouTube, go to Workflow Settings, set Error Workflow to T6-B1-Error-Handler. Save.

Note — The Error Workflow field only accepts workflows that are already Active. Since you verified T6-B1-Error-Handler is Active in Step 1, it will appear in the dropdown without issues.

Step 5 — Activate All Three Workflows in the Correct Order

n8n enforces a strict activation order: child workflows must be Active before the parent, or you will get a not published error when activating the parent.
  1. Activate T6-Content-Child-Blog first — toggle it to Active and confirm the status turns green.
  2. Activate T6-Content-Child-YouTube second — same process.
  3. Activate T6-Content-Factory-Dispatch last — only after both children are confirmed Active.

Production tip — Always follow the child-before-parent activation order whenever you deactivate and reactivate these workflows later. Forgetting this is the most common reason for the not published error in multi-workflow n8n setups.

Step 6 — Run a Clean Production Test

Test the live production execution path (not the UI test button) to confirm everything runs without errors.
  1. Inside T6-Content-Factory-Dispatch (which is now Active), click Execute once to trigger a production-mode run.
  2. Go to the Executions tab and confirm all runs show a Success status.
  3. Check your Telegram channel — if there are no workflow errors, no alert message should arrive. Silence here is correct behavior.

Tip — The UI test button (the flask/beaker icon) does not trigger the Error Workflow even if an error occurs. Only executions running from an Active workflow trigger the Error Handler. Always use Execute once from an Active workflow when you want to test production error alerting.

Step 7 — Inject a Fake Error to Verify Telegram Alerting

Deliberately breaking one child workflow confirms that your error alerting pipeline actually works end-to-end.
  1. Open T6-Content-Child-Blog and locate the HTTP Request node that calls your content endpoint.
  2. Change its URL to an intentionally wrong value (for example, add _broken to the end of the URL).
  3. Save T6-Content-Child-Blog — it remains Active with the bad URL.
  4. Go back to T6-Content-Factory-Dispatch and click Execute once again.
  5. Check Telegram — you should receive an error alert from T6-B1-Error-Handler within seconds. ✅
  6. Go back to T6-Content-Child-Blog, restore the correct URL, and save.
  7. Run Execute once one more time — confirm executions are clean and no Telegram alert fires.

Step 8 — Deactivate the Parent Workflow Until Needed

After the session, deactivate T6-Content-Factory-Dispatch to prevent it from running automatically at 8:00 AM until you are ready.
  1. Toggle T6-Content-Factory-Dispatch to Inactive on the dashboard.
  2. Leave T6-Content-Child-Blog, T6-Content-Child-YouTube, and T6-B1-Error-Handler as Active.
  3. When you want the schedule to run again, toggle the parent back to Active with one click — no other changes needed.

Note — Keeping the children Active while the parent is Inactive costs nothing and means reactivation later is instant. This is a clean pattern for managing n8n workflow automation schedules you want to pause temporarily.

Key Lessons from This Session

  1. Child workflows must be activated before the parent. n8n throws a not published error if the parent is activated while any child is still Inactive. Order: child Blog → child YouTube → parent Dispatch.
  2. The UI test button does not trigger the Error Workflow. You must run from an Active workflow using Execute once to test real error alerting behavior.
  3. "Continue (using error output)" adds a red output pin — this is normal. The pin is the error branch; you do not need to wire it up immediately, but it makes errors visible instead of swallowing them.
  4. Silence on Telegram after a clean run is the correct behavior. If no errors occur, no alert should fire — confirm this during your clean test run.
  5. Deactivating only the parent is enough to pause the schedule. Children and the error handler can stay Active, making re-enabling the whole system a one-click action.

Conclusion:

In this session of the n8n tutorial series, we transformed a manually-run Content Factory into a hardened n8n production workflow with scheduled execution, multi-level error handling, and live Telegram alerting. The end result is a system where failures surface immediately, the schedule is easy to pause and resume, and every layer — parent and children — is protected by the same error handler. Next up, we'll look at adding a quality gate using an AI review checklist before content gets posted, or extending the pattern with a new Email child workflow.

If you have any questions, feel free to leave a comment below. Thank you!

Tags: n8n production workflow, n8n tutorial, n8n workflow automation, n8n schedule trigger, n8n error handling, n8n execute sub-workflow, n8n content factory, workflow automation tutorial

Maybe you are interested!

Generate Student Assessment Rubrics Instantly with AI on Canva

On

Creating rubrics from scratch is tedious. That's where Canva's AI Rubric Maker comes in—a smart tool that generates assessment criteria templates in seconds. Instead of manually building evaluation frameworks, teachers can now leverage AI to produce structured grading rubrics based on specific criteria like content quality, technical skills, completion level, and creativity. A rubric itself is a scoring matrix used to grade assignments, projects, presentations, and other student work using predefined standards.

What makes this tool particularly useful is how it combines AI generation with Canva's design capabilities. The AI Rubric Maker generates an initial framework based on your input, then Canva lets you polish it into a visually appealing, printable format ready to share with students before they begin work. This transparency helps students understand exactly what's expected, while giving teachers a consistent evaluation framework. Here's how to set it up.

Step-by-Step Guide: Building Assessment Rubrics on Canva

Step 1: Access the AI Rubric Maker

Open Canva and tap the three-dot menu icon, then select Apps from the dropdown menu.

Type rubric into the search bar. Select the AI Rubric Maker result that appears.

Click on the AI Rubric Maker app to launch it.

You'll see an option to start with a new design or use an existing template. Choose your preference and continue.

Step 2: Configure Your Rubric Parameters

A new panel appears on the left side with input fields for your rubric settings. First, select Vietnamese as your language (or choose your preferred language for output).

Now fill in the remaining fields. For example, if you're grading student presentations, you'd add:

Learning Standards/Objectives:

Students will demonstrate the ability to construct and deliver clear presentations with accurate content, appropriate visual aids, and effective communication skills before an audience.

Task Description:

Students prepare a presentation on an assigned topic. The presentation must include an introduction, main content, conclusion, and relevant images or examples. Students should demonstrate presentation skills, explain concepts clearly, and answer questions from the teacher and peers.

When you're done entering information, click Generate.

Step 3: Add to Your Design

Wait a moment while the AI generates your evaluation criteria based on what you entered. Once the rubric appears, click Add to Design.

Your AI-generated assessment rubric is now embedded in your Canva design.

AI-generated rubric on Canva

What's important here is the next part: review and edit the generated content to ensure it aligns with your curriculum and your students' skill level. The AI gives you a solid starting point, but your professional judgment should shape the final rubric.


Related Articles

How to Generate Multiple-Choice Questions on Diemdanh

On

Diemdanh.app is an EdTech platform built for educators and instructional technology professionals who want to streamline their teaching workflows in one place. The platform's AI-powered question generator makes it incredibly easy to build multiple-choice assessments aligned with your lesson content—no more spending hours crafting questions from scratch.

What's particularly useful about this feature is its versatility across different subjects and use cases. Whether you need quick formative checks during class, end-of-lesson review materials, practice problem sets, or a question bank for future use, Diemdanh handles it all. Teachers can fine-tune generated questions to match their specific student groups' proficiency levels. Here's exactly how to get started.

Creating Multiple-Choice Questions on Diemdanh.app: A Step-by-Step Guide

Step 1:

Head to Diemdanh.app using the link below and set up your account.

https://diemdanh.app/

Step 2:

Once you're logged in, click on the "Create Quiz" button at the bottom of the dashboard, as shown below.

Next, enter a title for your quiz and then select between Practice mode or Test mode (Test mode includes a countdown timer).

Step 3:

Scroll down and you'll see two approaches for generating multiple-choice questions on Diemdanh.app. The first option lets you upload a file or image as source material for the questions.

Alternatively, you can type in your requirements directly using the AI assistant. Just specify the topic, subject area, target audience, and how many questions you want generated. Then click the "Create" button to let the AI do the work.

Step 4:

After a brief processing period, your generated multiple-choice questions appear and are ready to use. Students answer the questions and then click Submit when finished.

In the "View Created Quizzes" section, you'll find several handy options. You can download an answer key file for distribution, share a shareable link with students to take the quiz, and more.

Created multiple-choice quiz on diemdanh.app


Related Articles

n8n tutorial - Lesson 22: AI Image Generation in n8n with gpt-image-1

On
n8n tutorial - Lesson 22: AI Image Generation in n8n with gpt-image-1

Hi everyone, in this session of our n8n workflow automation tutorial series, we cover how to fix broken image generation after OpenAI killed DALL-E, migrate to gpt-image-1, and extend the Content Factory with a YouTube metadata child workflow — all real steps from an actual n8n image generation AI build.

How to do:

Step 1 — Understand Why DALL-E Stopped Working

Before touching any node, confirm the root cause so you fix the right thing.
  1. OpenAI permanently shut down DALL-E 2 and DALL-E 3 on 12 May 2026 (announced 14 November 2025). Any call to model: "dall-e-3" returns error code model_not_found with the message "The model 'dall-e-3' does not exist" — there is no grace period.
  2. The original plan from the previous session was to swap the OpenAI node for an HTTP Request node and simply remove response_format. That partial fix is not enough because the model itself no longer exists.
  3. Web-search to confirm the shutdown date before making any code change — never rely solely on AI knowledge when the situation is time-sensitive.

Note — This is a recurring lesson in production automation: when an AI assistant's training data is older than the current date, always run a quick search to verify before acting on its suggestion.

Step 2 — Migrate the Image Generation Node to gpt-image-1

Replace the dead DALL-E call with gpt-image-1 and update the request body to match the new API contract.
  1. Open your T6-Content-Child-Blog workflow and locate the node that previously called DALL-E (either an OpenAI node or an HTTP Request node).
  2. In the HTTP Request node, set the Body to:
    • model: gpt-image-1
    • prompt: your prompt expression
    • size: 1024x1024
    • n: 1
  3. Remove any response_format field from the body — gpt-image-1 does not accept it and will error if it is present.

Tip — The endpoint URL stays the same (https://api.openai.com/v1/images/generations). Only the model name and body shape change, so keep your existing Authorization header and credentials untouched.

Step 3 — Handle the Base64 Response (Replace the Download Image Node)

gpt-image-1 returns a Base64 string, not a URL — the old Download Image node is now useless and must be replaced.
  1. Understand the critical difference:
    • DALL-E 3 returned: data[0].url — a public URL you could GET directly.
    • gpt-image-1 returns: data[0].b64_json — a raw Base64 string.
  2. Delete (or disable) the Download Image node that previously performed a GET request on the image URL.
  3. Add a Code node named Base64 to Binary immediately after the HTTP Request node.
  4. Inside the Code node, write logic to:
    • Read $json.data[0].b64_json from the previous node's output.
    • Convert it to a binary buffer.
    • Return it as a binary field named data so downstream nodes (e.g., Google Drive upload) can consume it.
  5. Connect the Code node output to your Google Drive upload node and confirm the binary field name matches what the Drive node expects.

Tip — After uploading, set the file permission to Anyone with the link / Reader (Make Public) in Google Drive. Without this, the thumbnail embed in your blog HTML (<img src="https://drive.google.com/thumbnail?id={id}&sz=w1024">) will return a 403 for public readers.

Step 4 — Fix the Draft Post URL and Post ID Fields

Verify the actual field names returned by the Blogger POST Draft node — two fields from the previous session were guessed incorrectly.
  1. Run the Create Draft node against a real Blogger API call and inspect the raw output JSON.
  2. Confirm field mappings:
    • postId → use {{ $json.id }} (top-level field — this guess was correct).
    • blogId → use {{ $json.blog.id }}.
    • blogUrl → do not use {{ $json.url }} for a draft. For a DRAFT post, url only returns the blog homepage, not a permalink.
  3. For the edit link, construct it manually: https://www.blogger.com/blog/post/edit/{{ $json.blog.id }}/{{ $json.id }}

Note — A published post would populate url with the real permalink. Because this workflow saves drafts, the direct edit URL is more useful for review before publishing.

Step 5 — Build the YouTube Metadata Child Workflow

Create T6-Content-Child-YouTube as a 6-node workflow that generates YouTube SEO metadata and writes it to a Google Doc.
  1. Add a When Called by Another Workflow trigger node; define one input field: topic.
  2. Add an AI / Claude node (model: Claude Haiku 4.5) named YouTube SEO:
    • Connect it to a Structured Output Parser.
    • The prompt must demand JSON-only output with fields: title, description, tags, timestamps.
  3. Add a Code node named Format Doc Content to shape the parsed JSON into a readable Google Doc body string.
  4. Add a Google Docs node set to Create; note that the field holding the new document's ID in the output is id — not documentId (a common wrong guess).
  5. Add a second Google Docs node set to Update (Insert Text) to write the formatted content into the newly created document; reference the doc ID with {{ $json.id }}.
  6. Add a final Code node named Build YT Output; prefix all output fields with yt_ (e.g., yt_title, yt_tags, yt_docUrl, processedBy_YouTube) to prevent field collisions when Merging with Blog child output later.

Tip — This child workflow generates text metadata only — it does not create or upload a video. Auto-injecting this metadata into an actual YouTube upload requires a separate step: update the child to also write into the T5-Video-Metadata Sheet, which the upload workflow reads from.

Step 6 — Fix "Model Output Doesn't Fit Required Format" in the Output Parser

If the Structured Output Parser throws this error, tighten the prompt before reaching for advanced fixes.
  1. Edit the YouTube SEO node's system/user prompt to explicitly state: respond with JSON only, no markdown fences, no extra commentary, no trailing text.
  2. Test again — in most cases, this prompt strictness (Fix 1) resolves the error completely.
  3. The Auto-fixing Output Parser (Fix 2) is a more robust fallback that automatically retries malformed outputs. Keep this as a documented option for production hardening but do not implement it now unless Fix 1 fails.

Step 7 — Connect Both Children in the Parent Dispatch Workflow

Update T6-Content-Factory-Dispatch to fan out to both child workflows in parallel and merge their results.
  1. After the Limit node, draw two separate wires — one to Call Child Blog and one to Call Child YouTube.
  2. Set both Execute Sub-workflow nodes to Run once for each item so each topic spawns both children.
  3. Add a Merge node after both children; set its mode to Combine by Position.
  4. Connect both child output wires into the Merge node, then connect Merge to the Mark Done node.
  5. Test with one topic (e.g., "Top 5 amenities at Vinhomes Global Gate") and confirm:
    • Merge outputs exactly 1 item.
    • The item contains both blog fields and yt_-prefixed YouTube fields with no overwrites.

Production tip — The yt_ prefix on all YouTube child output fields is what prevents Merge from overwriting blog fields that share the same name (e.g., both children might output a title). Always prefix child outputs when multiple children feed a single Merge node.

Key Lessons from This Session

  1. DALL-E 2 and DALL-E 3 are permanently gone. Any workflow using those models must migrate to gpt-image-1 — there is no fallback or grace period.
  2. gpt-image-1 returns Base64, not a URL. Replace any "Download Image" node with a Code node that converts data[0].b64_json to a binary field.
  3. Draft Blogger posts do not return a real permalink. Build the edit URL manually from blog.id and id instead of relying on $json.url.
  4. Google Docs Create node returns id, not documentId. Always inspect raw output before writing expressions that reference node fields.
  5. Prefix child output fields to avoid Merge collisions. Use a consistent naming convention like yt_ for all fields from the YouTube child workflow.
  6. Prompt strictness fixes most Output Parser errors. Require JSON-only responses before reaching for the Auto-fixing Output Parser.
  7. Search before you fix, especially for API changes. When an AI tool suggests a fix for an API error, verify current model availability online first.

Conclusion:

In this n8n tutorial, we migrated image generation from the retired DALL-E to gpt-image-1, handled the Base64 response format correctly, fixed draft post field mappings, and built a parallel YouTube metadata child workflow — completing the core Content Factory. The next session focuses on production hardening: error output routing on each Execute Sub-workflow node, switching the parent trigger from Manual to Schedule, and linking an Error Handler workflow. If you have any questions, feel free to leave a comment below. Thank you!

Tags: n8n image generation AI, n8n tutorial, n8n workflow automation, gpt-image-1, n8n HTTP Request node, OpenAI image API, n8n sub-workflow, n8n Merge node

Maybe you are interested!

Build an Interactive Knowledge Train Drag-and-Drop Game Without Coding

On

Turning boring study questions into interactive games transforms how students engage with learning. Instead of students answering traditional questions one by one, educators can build dynamic drag-and-drop activities that turn practice sessions into play sessions. Here's what's interesting: you don't need any coding knowledge. With ChatGPT's help, you can generate a complete, functional HTML game from a single prompt.

This guide walks you through creating an interactive "Knowledge Train" game. The concept is elegant: students drag train cars onto tracks in the correct sequence, matching questions with answers. Each car contains two elements—the answer to the previous question on the left, and the next question on the right. This chain-linking approach makes knowledge connections visual and intuitive.

How to Build Your Knowledge Train Game

Step 1:

Open Gemini and switch to Canvas mode to begin building your game. Copy the prompt below into the interface.

Create an interactive HTML game called: KNOWLEDGE TRAIN.

Requirements:

- Build a standalone HTML file (HTML + CSS + JavaScript in one file) that works offline.

- Use bright 2D animations and colors suitable for elementary school students.

- Theme: educational train game.

- Include: locomotive, train tracks, multiple cars, and a draggable car depot.

- Students drag cars from the depot below onto the track in correct sequence.

Game Mechanics:

- The first car presents the opening question.

- Each car contains two sections:

 + Left side: ANSWER to the previous question.
 + Right side: NEXT QUESTION.

- When a car is placed correctly:
 
 + Car locks onto the track.
 + Play a success sound.
 + Show a subtle bounce effect.

- When a car is placed incorrectly:
 + Car returns to the depot.
 + Show a shake effect.
 + Play an error sound.

- Upon completion:
 + Display confetti animation.
 + Show congratulations message.
 + Animate the train moving left to right across the screen.

Layout:

- Top: "KNOWLEDGE TRAIN" title.

- Right side buttons:
 + Reset
 + Check
 + Shuffle

- Center area:
 + Locomotive on the left.
 + Empty slots for cars.
 + Horizontal scrollbar to view final cars.

- Bottom area:
 + Draggable car depot.
 + Horizontal scrollbar.

Data Structure (Teachers edit this):

const firstQuestion = "Who was the first king to establish our nation?";

const data = [

  {

    id: 1,

    answer: "King Hung",

    question: "According to legend, who invented sticky rice cakes and square cakes?",

  },

  {

    id: 2,

    answer: "Lang Lieu", 

    question: "Which three-year-old boy grew up overnight to fight invaders?",

  },

  {

    id: 3,

    answer: "Saint Giong",

    question: "Which two female war heroes rode elephants against enemy forces?",

  },

  {

    id: 4,

    answer: "The Two Trung Sisters",

    question: "Who placed wooden stakes in the Bach Dang River to defeat the Southern Han army?",

  },

  {

    id: 5,

    answer: "TEACHER ENTERS ANSWER",

    question: "TEACHER ENTERS NEXT QUESTION",

  },

  {

    id: 6,

    answer: "Ngo Quyen",

    question: "Complete!",

    label: "Finished"

  }

];

Technical Requirements:

- Enable mouse drag-and-drop functionality.

- Randomly shuffle cars in the depot.

- When a car is correctly placed, it disappears from the depot and appears on the track.

- Auto-scroll to the next empty slot when a car is added.

- Final car must always be draggable and never hidden.

- Clear horizontal scrollbars for both track and depot areas.

- Responsive design optimized for laptop screens.

- Large, readable fonts.

- No overlapping text or images.

- No external libraries required.

- Works completely offline.

- All code in a single HTML file.

Design Guidelines:

- Primary colors: sky blue, yellow, red, green.

- Rounded car corners with visible wheels.

- Left answer section: yellow background.

- Right question section: white background.

- Empty slots: dashed border outline.

- Fun effects without visual clutter.

Provide complete, production-ready HTML code so I can save it as .html and open it in Chrome immediately.

Step 2:

Wait a moment for the game to appear on the right side of your screen. Test it out. If you spot issues or want to adjust something, type your request in the left panel. Once satisfied, click the download icon to save the HTML file to your computer.

To play the game anytime, simply click the HTML file and it opens in any browser.

Here's what the game looks like in action. Students read questions, then drag and drop the correct cars to build their answer sequence and complete the train.


Related Articles

How to Use Gemini for Summarizing YouTube Videos

On

YouTube hosts an enormous library of knowledge and entertainment—millions of videos upload daily. But let's be honest: most of us don't have time to watch entire videos from start to finish.

If you're looking for an AI tool to handle video summaries, Gemini is an excellent choice. Just paste a video link and issue a simple command, and Gemini extracts the main points for you. What's interesting here is that Gemini goes beyond basic summaries—it can pull out key takeaways, list instructional steps, generate study notes, answer specific video-related questions, and reformat content into more digestible layouts. Here's how to get started with Gemini for YouTube video summaries.

How to Summarize YouTube Videos Using Gemini

Step 1:

Start by pasting the YouTube video link into Gemini's chat box. Then enter a command like the one below to analyze the video and extract key points:

Analyze and study this YouTube video, then extract the main ideas and critical points.

You can customize your request with variations such as:

  • Summarize the video in 200 words.
  • List the 10 main points from this video.
  • Explain the content in simple terms.
  • Create a beginner-friendly summary.
  • Convert the content into bullet points.
  • Extract step-by-step instructions from the video.
  • Rewrite the content as study notes.

Step 2:

Make sure to switch to the Pro model and hit send to process your YouTube video summary request.

Step 3:

Within moments, you'll receive a breakdown of the video's main content. Gemini organizes everything into distinct sections, making it easy to scan and absorb the information.

Step 4:

Want to turn this summary into a visual infographic? Use this command to convert the text into a graphic format:

Create a clear, clean study diagram or infographic from the information above.

Give Gemini a moment to process and generate an infographic based on the summary. Once it's ready, download the image as you normally would.

Important Considerations When Using Gemini for YouTube Summaries

Despite its usefulness, Gemini does have limitations:

  • Output quality depends on the data quality the AI can access.
  • Private or restricted videos cannot be analyzed.
  • AI may miss subtle details or nuance in the original content.
  • For highly technical videos, verify the original to double-check accuracy.

To get more accurate summaries from Gemini, follow these best practices:

  • Use specific prompts instead of vague requests.
  • Specify the desired length of the summary.
  • Ask for list format if you need note-taking structure.
  • Ask follow-up questions after the summary to clarify unclear points.
  • Use multiple prompts if you want a deeper analysis of different video sections.


Related Articles

n8n tutorial - Lesson 21: Sub-Workflows in n8n: Build Modular Automation

On
n8n tutorial - Lesson 21: Sub-Workflows in n8n: Build Modular Automation

Hi everyone, in this n8n sub workflow tutorial, you'll learn how to split a large automation into reusable child workflows using the Execute Workflow node. This is a core pattern in n8n workflow automation that keeps your projects modular, maintainable, and easy to scale.

How to do:

Step 1 — Understand When to Use Sub-Workflows

Before building anything, know the five situations where the sub-workflow pattern pays off in n8n workflow automation.
  1. Use a sub-workflow when the same logic is called from multiple parent workflows — for example, a "post to Blogger" routine used by both a blog factory and an email pipeline.
  2. Use it when a single workflow exceeds ~15 nodes and becomes hard to read or debug.
  3. Use it when you want to test one processing unit (text formatting, image generation, number math) independently without running the full parent.
  4. Use it when different team members own different stages — each person edits their own child workflow without touching shared logic.
  5. Use it when you need to process each item in a loop through a consistent set of nodes — the parent iterates, the child does the work.

Step 2 — Build Child Workflow A (Text Processor)

The first child workflow, T6-B2-Child-A-TextProcessor, receives a text string, transforms it to uppercase, and returns the result.
  1. Create a new workflow named T6-B2-Child-A-TextProcessor.
  2. Add a When Executed by Another Workflow trigger node. In the Input Schema, define one field: name text, type String.
  3. Add a Set node after the trigger. Configure three output fields:
    • result → expression {{ $json.text.toUpperCase() }}
    • processedAt → expression {{ $now.toISO() }}
    • processedBy → fixed string Child-A-TextProcessor
  4. Save the workflow, then click Test workflow with pinned data {"text": "hello sub workflow"}. Expected output: result: "HELLO SUB WORKFLOW".

Note — Depending on your n8n version, the When Executed by Another Workflow trigger's schema screen may only show Name and Type fields — there is no auto-generated sample value input box. You must pin test data manually to run standalone tests.

Step 3 — Build Child Workflow B (Number Processor)

The second child, T6-B2-Child-B-NumberProcessor, receives a number and returns its square — demonstrating that each child can use a completely different node type.
  1. Create a new workflow named T6-B2-Child-B-NumberProcessor.
  2. Add a When Executed by Another Workflow trigger. Define one schema field: name number, type Number.
  3. Add a Code node with the following JavaScript:
    • const n = items[0].json.number;
    • return [{ json: { squared: n * n, processedAt: new Date().toISOString(), processedBy: "Child-B-NumberProcessor" } }];
  4. Save and test with pinned data {"number": 7}. Expected output: squared: 49.

Step 4 — Build the Parent Dispatch Workflow

The parent workflow, T6-B2-Parent-Dispatch, sends data to both children in parallel and merges the results.
  1. Create a new workflow named T6-B2-Parent-Dispatch.
  2. Add a Manual Trigger node, then a Set node to mock input — set text to hello sub workflow and number to 7.
  3. From the mock input node, create two parallel branches:
    • Branch 1: Execute Workflow node → select T6-B2-Child-A-TextProcessor. Set Run once for all items. Map text → {{ $json.text }}.
    • Branch 2: Execute Workflow node → select T6-B2-Child-B-NumberProcessor. Set Run once for all items. Map number → {{ $json.number }}.
  4. Add a Merge node connected to both branches. Set Mode to Combine By Position.
  5. Run the parent and verify the merged output contains fields from both children: result, squared, and both processedAt values.

Tip — Use Combine By Position (not Combine By Matching Fields) when your two branches don't share a common key field. Combine By Matching Fields requires a shared identifier — in this demo, there is none.

Step 5 — Know the 7 Gotchas Before Going Further

These are the practical issues you will hit in real n8n sub workflow builds.
  1. Field name collision: If Child A and Child B both output a field called processedAt, the Merge node will overwrite one with the other. Rename fields to be unique per child (e.g., processedAt_A vs processedAt_B).
  2. Timezone offset: $now.toISO() returns local time; new Date().toISOString() in a Code node returns UTC. Be consistent across children to avoid confusion in logs.
  3. Cross-node reference breaks after deleting a node: If your child was duplicated from another workflow and still references a deleted node — e.g., $('Get Topics') — the expression will throw an error. Update every reference to point to the new trigger: $('When Executed by Another Workflow').
  4. Double-equals bug: In the Execute Workflow input mapping, if the field is already in Expression mode, type {{ $json.topic }} — do NOT prefix it with =. Writing ={{ $json.topic }} passes the literal string =Hướng dẫn... as the topic title instead of the actual value.
  5. Schema only validates, it does not inject sample data: The trigger schema defines expected input types. It does not create a test input form — pin data manually for standalone testing.
  6. Run mode matters: Run once for all items calls the child once and passes all items in a batch. Run once for each item calls the child once per item. Use "each item" when the child must process one topic at a time (e.g., the Content Factory).
  7. On Error behavior: Each Execute Workflow node has an On Error setting with three options: Stop Workflow (default — halts everything), Continue (skips the failed item silently), Continue (using error output) (routes the error to a separate output pin for handling). For production, set this to Continue (using error output) so one bad topic doesn't kill the whole batch.

Step 6 — Refactor Content Factory into Parent + Child

Now apply the sub-workflow pattern to a real project: the existing T4-B5-Blog-Batch workflow (14 nodes) is split into a parent dispatcher and a child blog generator.
  1. Design the split:
    • Parent (T6-Content-Factory-Dispatch): reads topics from Google Sheet T4-B5-Blog-Topics, calls the child for each topic, marks the sheet row as done.
    • Child (T6-Content-Child-Blog): receives one topic string, generates HTML blog post, posts draft to Blogger, returns topic / status / postId / blogUrl.
  2. Build the child workflow:
    1. Duplicate T4-B5-Blog-Batch. Rename it T6-Content-Child-Blog.
    2. Delete the Get Topics, Limit, and Mark Done nodes.
    3. Add a When Executed by Another Workflow trigger with schema field topic (type String).
    4. Find every expression that references $('Get Topics') and replace it with $('When Executed by Another Workflow').
    5. Add a final Set node (Build Output) that returns: topic, status, postId (from $json.id of the Blogger POST response), blogUrl (from $json.url).
  3. Build the parent workflow:
    1. Duplicate T4-B5-Blog-Batch. Rename it T6-Content-Factory-Dispatch.
    2. Delete the 11 internal processing nodes, keeping only: Manual Trigger → Get Topics → Limit → Mark Done.
    3. Insert a Call Child Blog (Execute Workflow) node between Limit and Mark Done. Select T6-Content-Child-Blog. Set Run to Run once for each item.
    4. Map the child input: field name topic, value {{ $json.topic }} (no leading =).
    5. In the Mark Done node, set the match condition to topic = {{ $json.topic }} — this uses the topic field returned by the child output, ensuring the correct sheet row is marked regardless of item ordering.

Production tip — Always match Mark Done using a value from the child's output (not the parent's pre-call data). If the child transforms or normalizes the topic string, matching against the child's returned topic field prevents row-pairing mismatches in your sheet.

Step 7 — Test the Full Content Factory and Fix Errors

Run the parent with one topic in the sheet and work through the three errors that appear in a typical first run.
  1. Error 1 — DALL-E response_format known issue:
    • The OpenAI DALL-E node throws an error related to the response_format parameter on certain n8n versions.
    • Workaround: disable the DALL-E node and its 3 downstream image-handling nodes in T6-Content-Child-Blog. The blog post will be created without an image until this is fixed in Session 22.
  2. Error 2 — Double-equals in topic title:
    • Symptom: the blog post title appears as =Hướng dẫn... (the raw expression string, not the evaluated value).
    • Fix: open the Call Child Blog node, find the topic input field, confirm it is already in Expression mode, and change the value from ={{ $json.topic }} to {{ $json.topic }}.
  3. Error 3 — Broken cross-node reference:
    • Symptom: child workflow throws Referenced node does not exist: Get Topics.
    • Fix: search the child for every expression containing $('Get Topics') and replace with $('When Executed by Another Workflow').
  4. After all three fixes, run the parent again. Expected results:
    • Blogger draft created with clean title ✅
    • Google Sheet row marked as done ✅
    • No expression errors ✅

Note — The DALL-E issue is a known bug in specific n8n versions. The fix — replacing the OpenAI node with an HTTP Request node calling images/generations directly without the response_format parameter — is scheduled for the next session.

Key Lessons from This Session

  1. Always test each child workflow standalone before connecting to the parent. Pin sample data to the trigger and verify output before wiring the Execute Workflow node in the parent.
  2. Use Combine By Position when branches share no common key field. Combine By Matching Fields requires a shared identifier — if none exists, the merge will silently drop rows.
  3. The double-equals bug (={{ }}) passes a literal string, not an expression. If an input field is already in Expression mode, write {{ $json.field }} without the leading =.
  4. Cross-node references break when the referenced node is deleted. After duplicating a workflow and removing nodes, audit every expression for references to deleted node names.
  5. Match Mark Done using the child's output topic, not the parent's pre-call data. This prevents sheet row mismatches when items are processed out of order.
  6. Set Execute Workflow error handling to "Continue (using error output)" in production. This routes failed items to a separate pin instead of stopping the entire batch.
  7. Run once for each item vs. run once for all items controls batching behavior. Use "each item" when the child must handle one record at a time with its own context.

Conclusion:

In this n8n sub workflow tutorial, you built a full three-workflow demo — two standalone child processors and a parent dispatcher — then applied the same pattern to a real Content Factory by refactoring a 14-node monolith into a clean parent-plus-child architecture. The sub-workflow pattern is the foundation for orchestrating multi-format content pipelines in n8n tutorial series like this one, and every production technique covered here (error routing, expression mode awareness, cross-node reference auditing) will carry forward into more advanced n8n workflow automation builds. Next session covers re-enabling the DALL-E image branch with a direct HTTP Request workaround, verifying postId and blogUrl output values, and expanding the factory to dispatch to YouTube and Email child workflows.

If you have any questions, feel free to leave a comment below. Thank you!

Tags: n8n sub workflow tutorial, n8n tutorial, n8n workflow automation, Execute Workflow node, modular automation, n8n Content Factory, n8n beginner to advanced, workflow design patterns

Maybe you are interested!

How to Disable and Control AI Features on Your Samsung Galaxy Phone

On

Artificial intelligence has become inseparable from modern smartphones. Every major manufacturer is loading their devices with increasingly sophisticated AI capabilities, and Samsung is leading the charge. From virtual assistants and real-time translation to photo editing tools and writing assistance, AI is everywhere on the latest Galaxy lineup.

But here's the thing: not every user wants AI integrated into every aspect of their phone experience. Some people only need a handful of useful features, while others prioritize privacy or want to reduce unnecessary background services consuming system resources.

The good news? Samsung actually gives you real control over Galaxy AI. You can enable or disable individual features without touching others, or limit how AI processes your data—all without diving into confusing settings menus.

What Exactly Is Galaxy AI?

Galaxy AI is Samsung's umbrella term for the AI technologies integrated into its latest devices. It's a collection of features including live call translation, writing assistance, text summarization, AI-powered photo editing, intelligent search, and several other productivity tools.

Samsung's vision is to make your smartphone a smarter personal assistant—one that can help with both work and daily life. The catch? Not everyone needs or wants access to this entire AI ecosystem. That's why Samsung built in flexible management options.

How to Disable Individual Galaxy AI Features

Many Galaxy AI features genuinely save time and effort. Rather than turning everything off, most users prefer to disable only the tools they don't actually use.

To manage individual AI services on your Samsung Galaxy phone, follow these steps:

  • Open Settings.
  • Tap Galaxy AI.
  • Select the specific AI feature you want to adjust.
  • Toggle the switch to Off to disable that feature.

This screen displays your complete Galaxy AI toolkit. You can switch individual features on or off based on your actual needs instead of disabling the whole system at once.

What's interesting here is this granular approach—you keep the tools that genuinely improve your workflow while eliminating the clutter of features you rarely touch.

Restricting AI to On-Device Processing Only

Privacy-conscious users will appreciate another option Samsung offers.

At the bottom of the Galaxy AI settings screen, there's a toggle that lets you limit data processing to your device itself, rather than sending information to Samsung's cloud servers.

When you enable this mode, your phone processes AI tasks directly on its hardware. This reduces the amount of data traveling over the internet and strengthens your personal data protection.

There's a tradeoff, though. Some AI features rely on cloud server processing, so they'll either stop working or perform less effectively. In certain cases, the quality of results may suffer compared to using full cloud services.

Ditching Bixby If Samsung's AI Isn't Your Style

Beyond Galaxy AI, there's Bixby—Samsung's virtual assistant that's been integrated into devices for years. Plenty of users have probably forgotten it's even running in the background.

If you want to minimize Samsung's AI footprint, replacing or disabling Bixby is worth considering.

Samsung now lets you choose a different default assistant. In most cases, Google Assistant is the popular choice thanks to its broad compatibility and robust feature set.

That said, options vary depending on your Galaxy model. On the newer Galaxy S26 series, for example, Bixby isn't the default assistant anymore. If you install the Perplexity app, you can even set that as your replacement assistant.

How to Replace Bixby with Google Assistant

To switch to Google Assistant instead of Bixby, follow these steps:

  • Open Settings.
  • Go to Apps.
  • Tap Default Apps.
  • Select Digital Assistant App.
  • Choose Google.

From now on, whenever you activate voice assistant on your phone, Google Assistant handles the request instead of Bixby.

Beyond Google Assistant, other options depend on which AI apps you've installed. Newer AI assistant platforms may also appear in your list if they support Android system integration.

Should You Turn Off Galaxy AI Completely?

The answer depends on how you actually use your phone.

If you regularly take advantage of features like language translation, writing support, smart search, or AI photo editing, keeping Galaxy AI enabled offers real practical value.

On the flip side, if privacy is your main concern, you want to reduce background services, or you simply don't want AI features cluttering your interface, disabling the unnecessary tools will give you a cleaner experience.

The real concern is this: Samsung isn't forcing you to use their entire AI ecosystem. You're completely free to choose exactly how much AI appears on your device.

Samsung keeps adding more AI features to Galaxy devices, but the decision about how to use them remains yours. Through the Galaxy AI section in settings, you can easily enable or disable individual features, restrict data processing to your device, or swap out Bixby for a different assistant that better matches your preferences.

For most people, the sweet spot isn't eliminating AI entirely. Instead, it's keeping the features that genuinely improve your daily workflow while disabling the tools that don't add value. That way, you get the benefits of AI while maintaining full control over your phone.

Related Articles

Subscribe to: Posts (Atom)

Copyright © 2016 QTitHow All Rights Reserved