How to Use n8n with ._Template 114 Newsletter Curada Ia Digest

Your team subscribes to 40 newsletters, three Slack digests, a handful of RSS feeds, and two industry Substacks. Nobody reads them. The signal is real, but the format is hostile to a busy schedule: it arrives at random hours, buried in promotional filler, and demands that a human sit and skim. By Friday, the "must-read" AI briefing you paid for is 200 unread emails deep. Template 114 — the Newsletter Curada IA Digest — exists to solve exactly this: it uses n8n to ingest every source you care about, let an LLM rank and summarize what actually matters, and deliver one clean digest on your schedule.

The problem: information you pay for but never consume

Curation is a labor problem disguised as a content problem. The content exists; the bottleneck is the human attention required to filter it. Manual triage fails for three predictable reasons:

• Fragmentation. Sources live in email, RSS, Reddit, and APIs. There is no single inbox, so there is no single review moment.
• No prioritization. A vendor's product announcement and a genuine research breakthrough arrive with identical visual weight. Your brain spends the same energy dismissing both.
• Timing mismatch. Content publishes when the publisher wants, not when you have ten focused minutes. Anything not read on arrival is effectively lost.

The result is spend without return: you (or your ops team) pay for premium newsletters and never extract the insight that justified the subscription.

The solution: an automated curation pipeline

Template 114 restructures the workflow around a simple principle — let machines gather and rank, let humans decide. Instead of you visiting sources, the sources flow into a single n8n pipeline that runs on a fixed schedule. An AI model reads everything, scores each item for relevance against your defined interests, deduplicates near-identical stories, and writes a tight summary of the top N. You receive one message: a ranked, deduplicated, summarized digest.

The architecture is four logical stages: ingest → normalize → rank & summarize → deliver. n8n is the ideal glue here because each stage maps cleanly to a node, and the branching logic (dedup, thresholds, formatting) lives in code nodes you fully control — no black box deciding what your team sees.

Step-by-step setup in n8n

The following assumes a self-hosted or cloud n8n instance with your credentials configured. Build it incrementally and test each stage before wiring the next.

1. Trigger. Start with a Schedule Trigger node. For a daily digest set it to a cron expression like 0 7 * * * (07:00 every day). A weekly ops digest works well at 0 8 * * 1. Keep the cadence predictable — the whole point is that the digest arrives when your team is ready for it.

2. Ingest sources. Add one input branch per source type:

• RSS Feed Read nodes for blogs and Substacks that expose a feed. One node per feed URL, or loop a list with a Split In Batches node.
• An IMAP Email trigger or the Gmail node (search query label:newsletters is:unread newer_than:1d) for email-only sources.
• HTTP Request nodes for anything with an API — Reddit's /r/subreddit/top.json, Hacker News' Algolia endpoint, or a vendor REST feed.

3. Normalize. Merge every branch with a Merge node (mode: Append), then pass through a Code node that maps each item to a consistent schema: { title, url, source, publishedAt, rawText }. Strip HTML from rawText here so you don't waste tokens later. This normalization step is what lets the AI treat an email and a Reddit thread identically.

4. Deduplicate. Newsletters aggressively republish the same story. In a Code node, hash a normalized version of each title (lowercase, remove punctuation and stopwords) and drop collisions. For fuzzy near-duplicates, keep the item with the earliest publishedAt. This alone cuts volume by 20–40% before you spend a single token.

5. Rank and summarize with an LLM. This is the core. Use the Anthropic node (or an HTTP Request to the Messages API) with a current model — claude-sonnet-5 is the right balance of quality and cost for high-volume summarization; step up to claude-opus-4-8 if your relevance judgments need deeper reasoning. Batch items into a single call rather than one call per item — cheaper and gives the model cross-item context for ranking. Prompt structure:

• System: Define the persona and your team's interests explicitly — "You curate an AI/ops digest for a technical founder. Prioritize: production ML tooling, agent frameworks, pricing/regulation shifts. Ignore: generic funding news, listicles, thought-leadership."
• User: Pass the deduplicated array as JSON. Ask for structured output: a relevance score 0–10, a one-line summary, and a "why it matters" clause per item.
• Force JSON output so the next node can parse deterministically. Set max_tokens generously and enable prompt caching on the system block since it's identical every run — this meaningfully cuts cost at daily cadence.

6. Filter and sort. A Code node parses the LLM response, drops anything below your score threshold (start at 6), and sorts descending. Cap the output at your top 8–10 so the digest stays scannable.

7. Format and deliver. Build the digest body with a Code or Set node — a ranked list with title, one-line summary, "why it matters," and source link. Then fan out to your delivery channels: the Gmail/Send Email node for a formatted HTML email, the Slack node (chat.postMessage) for a team channel, or a Notion/Telegram node. Keep the source URL on every item so a reader can always drill in.

8. Handle failures. Set each ingest node's Continue On Fail so one dead RSS feed doesn't kill the whole run, and add an Error Trigger workflow that pings you if the pipeline itself breaks.

Benefits: what the pipeline actually returns

The payoff compounds daily:

• Time recovered. A curation habit that took 45 scattered minutes collapses to a five-minute read of a ranked list.
• Consistency. The digest ships whether or not anyone remembers to look. Coverage no longer depends on discipline.
• Higher signal. Because the LLM scores against your explicit interests, the noise floor drops — you stop paying attention tax on irrelevant items.
• Institutional memory. Route the formatted output to a Notion database or Google Sheet and you accumulate a searchable, timestamped archive of everything that mattered — invaluable for onboarding and trend spotting.
• Cheap to run. With deduplication, batching, and prompt caching, a daily digest over dozens of sources costs cents per run.

Common pitfalls and how to avoid them

Vague relevance criteria. If your system prompt says "important AI news," the model returns generic slop. Be specific about what to elevate and what to suppress, and revise the prompt weekly for the first month based on what the digest surfaces.

Sending raw HTML to the model. Newsletter emails are bloated with tracking pixels, footers, and markup. Strip to plain text in the normalize step or you'll pay for thousands of junk tokens and degrade summary quality.

One API call per item. This is the most common cost mistake. Batch all items into a single request so the model can rank comparatively and you pay the system-prompt overhead once.

Skipping deduplication. Without it, your digest repeats the same story five times from five sources and the reader loses trust immediately. Dedup before the LLM call, not after.

Over-delivering. A 30-item "digest" is just the original problem in a new wrapper. Enforce a hard cap and a score threshold. Fewer, higher-quality items is the entire value proposition.

No failure handling. RSS feeds go stale, APIs rate-limit, credentials expire. Use Continue On Fail on ingest nodes and an Error Trigger so a partial run still delivers and a total failure still alerts you.

Set it up once, tune the prompt for a week, and Template 114 turns a pile of unread subscriptions into the one briefing your team actually opens.