I automated a news site with n8n: from 20 RSS feeds to WordPress drafts

I built an n8n pipeline that watches around twenty RSS feeds, discards what it has already seen, scores each story with a cheap model, rewrites only the ones worth covering with a more capable model, and leaves the result as a WordPress draft-with a cover image and a Telegram alert. The goal wasn't to "publish on its own"; it was to remove the mechanical work: reading dozens of sources, deciding what deserves coverage, and leaving a first draft ready to review. The whole flow runs every three hours without me touching anything, and what matters isn't the nodes but the three or four design decisions that keep it from filling up with irrelevant content or blowing up the token spend.

TL;DR

• Deduplicate before spending: hash the link and let Postgres reject repeats with ON CONFLICT DO NOTHING. That way you don't scrape or rewrite the same story twice.
• Use a cheap model to score relevance from 0 to 100 before rewriting: only what clears the threshold reaches the expensive model. Premium spend is the exception, not the rule.
• Leave everything as a draft, not published. The automation proposes; you approve. And alert yourself on Telegram so you review in time.

What the pipeline does and why I automated it

I built it for a friend who runs a news site on WordPress. I won't say which one-it's his project, not mine-but the pattern carries over to any outlet with the same problem: the bottleneck wasn't writing, it was the work that comes before. Opening twenty sources, reading headlines, deciding what's interesting for the audience, and putting together a first draft eats up more time than polishing the final text. That work is repetitive and has clear rules, so it's exactly the kind of task worth automating.

The pipeline does exactly that round trip. Every three hours it reads the feeds, keeps what's new, discards the irrelevant with a cheap filter, rewrites what deserves coverage into an original SEO-optimized article, attaches an image, and leaves it as a draft. The editor only steps in to review what's already almost ready. It isn't a spam generator: it's a writing assistant that does the mechanical part and leaves the editorial decision to a person.

The key is that every step is designed to spend the minimum. Not everything that comes in through a feed deserves a call to an expensive model, or even deserves to be downloaded. The flow is, in essence, a sequence of filters ordered by cost: the cheap ones go first and discard most of it, so the expensive ones only process what makes it to the end.

The flow end to end

Before getting into each piece, this is the complete shape of the pipeline. It reads left to right, and each arrow is an output of an n8n node:

Schedule (every 3h)
│
▼
Feed list ──► Split ──► RSS Read ──► Cap 3 per feed (Code)
│
▼
Hash the link (SHA256)
│
▼
Postgres: insert + dedup
│
is it new?
│
┌──────────┴───── No ──► discard
│ Yes
▼
Scrape (Firecrawl)
│
▼
Cheap LLM: score 0-100
│
score ≥ 70?
│
┌──────────┴───── No ──► discard
│ Yes
▼
Tiered LLM: rewrite (Claude if score ≥ 85, otherwise Gemini)
│
▼
Image (Unsplash) ──► WordPress (draft) ──► cover
│
▼
Postgres: mark published ──► Telegram

There are three blocks: get candidates (schedule, feeds, RSS), filter them cheaply (dedup and score), and produce the draft (rewriting, image, WordPress, alert). The order isn't accidental: each filter is placed to discard as early as possible, while discarding is still free.

Keep reading

That is the first half. The full walkthrough-with the rest of the implementation, the trade-offs and the things that only show up in production-is on my blog:

Read the full post on ramonchancay.me →

Originally published at www.ramonchancay.me/blog/news-pipeline-n8n-rss-wordpress.