DEV Community: Lan Exequiel Mislang

Morning Course Digest for Coaches Node Logic Deep Dive

Lan Exequiel Mislang — Wed, 28 Oct 2026 15:02:08 +0000

At 6:15 am a coach opens their laptop to review yesterday’s student messages. Before coffee is finished, a Slack notification pings: "New course digest ready." The workflow has already gathered the latest articles from three RSS feeds, extracted the key takeaways, and posted a formatted summary to the #coaching‑updates channel. This is what the Morning Course Digest for Coaches workflow does each morning.

At a glance

Built for: coaches and course creators
Difficulty: beginner
Starts with: Schedule Trigger (scheduleTrigger)
Steps: 5 nodes
Tools: n8n, Slack, RSS Feed

Schedule Trigger – scheduleTrigger

The workflow begins with the scheduleTrigger node. It is configured to run at 06:00 local time every weekday. When the trigger fires, it passes an empty execution context to the next node. No input data is required; the trigger simply starts the cycle at the set interval.

Fetch RSS Feed – httpRequest

The httpRequest node receives the empty context from the schedule trigger and issues GET requests to the three selected RSS feed URLs. Each response contains an XML payload with items, each item having a title, link, and description. The node outputs an array of RSS items; each item includes the raw XML fields plus any metadata the node adds, such as the fetch timestamp. A typical output item looks like { "title": "Advanced Python Techniques", "link": "https://example.com/python-tips", "description": "Learn decorators and context managers." }.

Split RSS Items – splitInBatches

The splitInBatches node receives the array of RSS items from the httpRequest node. It separates the items into individual batches so that each item can be processed independently in the code node. The node does not alter the item structure; it simply outputs one execution per RSS item, passing the full item object down the branch. This allows the code node to run once per article rather than once for the entire feed.

Summarize Content – code

The code node receives one RSS item at a time from the splitInBatches node. Inside the node’s JavaScript function, the raw description text is extracted and trimmed. A simple prompt is constructed using an expression: {{$json["description"]}}. The function then generates three concise, actionable points: the main topic, a practical takeaway, and a suggested next step for a coach. The output is a new JSON object attached to the execution, for example { "summary": "Topic: Using decorators to reduce boilerplate. Takeaway: Wrap repetitive logging. Next step: Apply to your onboarding emails." }.

Post to Slack – slack

The slack node gathers the summarized outputs from all code executions. It formats the results into a single message block, prepending the article title and linking back to the source. The node then posts the formatted text to the chosen Slack channel. The final message might read:
"📚 Advanced Python Techniques
Learn decorators and context managers.
• Topic: Using decorators to reduce boilerplate.
• Takeaway: Wrap repetitive logging.
• Next step: Apply to your onboarding emails.
Read more: https://example.com/python-tips"

Worked Example

Input (RSS item):
{ "title": "Time‑boxing Coaching Sessions", "link": "https://coachingblog.com/timeboxing", "description": "A quick method to structure 30‑minute client calls with clear start, middle, and end phases." }

After splitInBatches:
The item is passed to the code node as a single execution context.

After code:
The node produces { "summary": "Topic: Time‑boxing structure for 30‑min calls. Takeaway: Define start, middle, end phases. Next step: Map your own client intake flow." }.

After slack:
The Slack message posted reads:
"📚 Time‑boxing Coaching Sessions
A quick method to structure 30‑minute client calls with clear start, middle, and end phases.
• Topic: Time‑boxing structure for 30‑min calls.
• Takeaway: Define start, middle, end phases.
• Next step: Map your own client intake flow.
Read more: https://coachingblog.com/timeboxing"

Watch Out For

The httpRequest node relies on the RSS feeds being well‑formed. If a feed returns HTML error pages or missing description fields, the code node may throw an error or produce incomplete summaries. Adding a Set node before the code step to check for the existence of description can prevent failures.

Key takeaways

The scheduleTrigger starts the workflow each morning without manual input.
The httpRequest node fetches raw RSS data from selected feeds, outputting individual items.
The splitInBatches node isolates each item so the code node can summarize them one at a time.
The code node generates concise actionable points from the article description.
The slack node posts the formatted summary to a chosen channel, linking back to the source article.

Before you import it

A running n8n instance (cloud or self-hosted).
n8n account
Slack workspace access
RSS feed URLs for course content
Sample data to test with, before pointing it at real records.

Get the free workflow

The importable JSON for Morning Course Digest for Coaches is free to download: https://lanexbuilds.com/library

This workflow was generated with AI assistance. Test it with sample data before using it on real data.

Cover photo by StartupStockPhotos on Pixabay

Morning Course Digest for Coaches Node Logic Deep Dive

Lan Exequiel Mislang — Wed, 28 Oct 2026 08:09:51 +0000

The alarm at 06:30 rings across a quiet home office. A coach opens her laptop and glances at the Slack channel dedicated to course updates. The daily summary has already arrived, compiled from three RSS feeds she follows. She scans the bullet points, picks one link to read fully, and drafts a response to a student all before her first client call at 09:00. This workflow automates that morning compilation.

At a glance

Built for: coaches and course creators
Difficulty: beginner
Starts with: Schedule Trigger (scheduleTrigger)
Steps: 5 nodes
Tools: n8n, Slack, RSS Feed

Schedule Trigger Node

The scheduleTrigger node is the entry point for the workflow. It is configured to fire at 07:00 UTC every morning. On each run, it outputs a single execution context that downstream nodes inherit. The node does not fetch any data itself; it simply signals the start of the run and passes the current timestamp to the next node in the chain.

Fetch RSS Feed Node

The httpRequest node receives the trigger payload from the schedule and initiates three separate HTTP GET requests to the configured RSS feed URLs. Each request returns an XML document structured with channel items, including title, link, description, and pubDate. The node outputs an array of these items, which can number from a handful to dozens depending on how recently each feed was updated. The node handles basic HTTP errors, but if a feed is permanently down, the workflow stops at this point unless error handling is added.

Split In Batches Node

The splitInBatches node takes the array of RSS items from the previous node and breaks them into manageable chunks. A batch size of 5 is typical, meaning if 12 items are returned, the workflow creates three batches: two full batches of five and one final batch of two. Each batch is processed independently by the next node, allowing the summarization logic to run in parallel across groups of articles rather than one by one.

Code Node

The code node receives one batch of RSS items at a time. Inside the function, the node iterates over the items and extracts the title and description fields. It then constructs a prompt that asks the large language model to summarize the content into three concise, actionable points suitable for a coach’s audience. The node outputs a single string per batch, formatted as markdown with a bold title link and a bullet list of points. If the description is missing, the node skips that item and logs a warning, ensuring the output does not contain broken references.

Slack Node

The slack node gathers the formatted summary strings from all batches and posts them to a specified Slack channel via an incoming webhook. The message includes the date at the top and a divider line before the bullet points. The node outputs a confirmation ID from Slack, which the workflow uses to verify delivery, but the coach sees only the published message in the channel.

Worked Example

Input (fictional RSS item):

{
  "title": "10 Productivity Hacks for Online Coaches",
  "description": "Learn how to batch your client sessions, use timers for focus blocks, and automate your email follow-ups. Updated this week.",
  "link": "https://examplecoachblog.com/productivity-hacks"
}

After scheduleTrigger: The workflow begins; timestamp 2024-05-20T07:00:00Z is attached to the execution.

After httpRequest: The item is included in the XML response array alongside other feed entries.

After splitInBatches (batch size 3): This item resides in the first batch of three.

After code node: The output string is:

**10 Productivity Hacks for Online Coaches**
- Batch client sessions to reduce context switching.
- Set timers for deep focus blocks during peak hours.
- Automate email follow-ups after each session.

After slack node: The message appears in the "course-digest" channel with the date prefix and the markdown above.

Key takeaways

The scheduleTrigger node fires on a cron-like schedule and passes a timestamp to downstream nodes.
The httpRequest node fetches raw XML from RSS feeds and outputs an item array that may vary in length.
The splitInBatches node divides the item array into chunks so the code node can process them in parallel batches.

Before you import it

A running n8n instance (cloud or self-hosted).
n8n account
Slack workspace access
RSS feed URLs for course content
Sample data to test with, before pointing it at real records.

Get the free workflow

The importable JSON for Morning Course Digest for Coaches is free to download: https://lanexbuilds.com/library

This workflow was generated with AI assistance. Test it with sample data before using it on real data.

Cover photo by Tumisu on Pixabay