Originally published on longevityai.nl — for full context, comments and related articles, visit the source.

How I Built a Health-Content Autopilot for €12/Month

I run Longevity AI, a Dutch holistic health platform. The content side was killing me. Writing one good evidence-based blog took 4-6 hours. I had nine ziektebeelden (chronic conditions) to cover, in three languages. That's roughly 50 blogs per year I could realistically produce. Not enough.

So I built an autopilot. Here is how it works, what it costs, and what I had to fight to keep it ethical.

The Problem: Quality Health Content Does Not Scale

Health content has a quality floor that most blog-automation systems crash into. You cannot just pull RSS feeds and rephrase them. You need:

• Peer-reviewed sources — citation from PubMed, EFSA, ClinicalTrials.gov
• Compliance — Dutch IGJ, EU MDR, AVG (GDPR) all apply
• Three languages — Dutch primary, English and French as syndication
• Cover image + inline visuals — readers do not engage with text walls

My first attempt used GPT-4o-mini + Flux + manual review. Per blog: ~€0.50. Per cycle (every 6 hours, 3-5 blogs): €1.50-2.50. Per month: €120-240. Fine, but bleeding for a solo operation.

The Architecture: 4 Scrapers, 1 Orchestrator, 1 Gate

The autopilot has four input sources. Each one is a separate scraper that returns a normalized signal object:

interface ContentSignal {
  title: string;
  topic: string;
  sourceText: string;   // article body
  sourceUrl: string;    // canonical link
  language: "nl";
  ziektebeeldIfKnown?: string;
  tags?: string[];
}

The four scrapers:

1. BBC Health RSS — keyword-filtered for supplement, treatment, nutrition, sleep, immune, gut, etc.
2. NCBI PubMed eUtils — per-ziektebeeld scientific queries, rate-limited to 3 req/sec
3. EFSA RSS — EU supplement approvals and health claims (high-trust EU regulator)
4. ClinicalTrials.gov REST — 7-day rolling window of new trial registrations

The orchestrator:

export async function runNewsRadarCycle(): Promise<void> {
  const db = await getDb();
  if (!db) return;

  const bbcArticles = await scrapeBBCHealthFeed();
  for (const article of bbcArticles) {
    if (await signalAlreadyExists(db, article.link)) continue;
    await createSignal(db, { /* ... */ });
  }

  for (const ziektebeeld of Object.keys(LAB_FOLDER_BY_ZIEKTEBEELD)) {
    const studies = await scanPubMedForZiektebeeld(ziektebeeld);
    for (const study of studies) {
      // dedup + insert
    }
  }
  // EFSA + ClinicalTrials same pattern
}

Deduplication is two-layer: URL-hash in the orchestrator and a query check in signalAlreadyExists() against the database. Both layers are necessary because the same study can appear in PubMed and ClinicalTrials with different URLs.

The Compliance Gate (The Hardest Part)

Health content in the EU is a minefield. The IGJ (Dutch healthcare inspectorate) regularly fines wellness sites for treatment claims. The MDR (medical device regulation) governs anything that sounds like diagnostic advice. So I built a hard gate:

const complianceResult = await runComplianceCheck(sourceText);
const isSafe = complianceResult.verdict === "SAFE";

if (!isSafe) {
  status = "pending_review";  // never auto-publishes
} else {
  status = "pending_auto_blog";  // proceeds to blog generation
}

The compliance check uses Claude to evaluate against a curated set of rules: no diagnostic claims, no treatment imperatives, no cure language, no medication-stop advice. Verdict is SAFE / WARN / BLOCK. Only SAFE proceeds to auto-publish.

This matters for one specific feature: affiliate links. I only inject affiliate links into 100% SAFE articles. Anything that fails compliance goes to manual review. The disclosure is explicit:

Wat je hierboven leest, is gebaseerd op peer-reviewed wetenschap en officiële gezondheidsrapporten. Wij noemen supplementen en bloedtests alleen op basis van wetenschappelijk bewijs.

Transparency over deception. I had to push back on my own design here — the temptation to just hide AI-generation is real. But that crosses a line I will not cross.

The Cost Reduction (90% in One Refactor)

After running for a few weeks I looked at the bill: €180/month for content the audience read for 30 seconds each. Time to optimize.

Three changes, each independent:

Component	Was	Now	Savings
LLM	GPT-4o-mini	Claude Haiku	90% on LLM cost
Images	Flux (Together.ai)	Stability AI	70% on image cost
Cycles	Every 6 hours	Every 12 hours	50% fewer API calls

The LLM swap was the biggest win. Claude Haiku writes more naturally than GPT-4o-mini for long-form Dutch content. I had assumed the cheaper model would mean worse output. It does not. It means different output, and for technical-but-friendly health content, Haiku wins.

The image swap was equally surprising. Stability AI's stable-diffusion-3-large produces images that are 80% as good as Flux for 30% of the cost. For inline blog images that readers glance at for 2 seconds, that trade is obvious.

Cycle frequency was the easiest win. Going from 6 to 12 hours did not affect the freshness of the content the audience saw. PubMed studies do not become stale in 6 hours.

Final cost: €12-20/month. Same quality. Same pipeline. Same compliance.

Auto-Syndication: One Source, Three Platforms

Once a blog is generated and published on longevityai.nl, the system checks if it has a technical tag. If yes, it auto-syndicates to Hashnode and Dev.to:

if (lang === "en" && hasTechnicalTag(blog.tagsCsv)) {
  await Promise.all([
    publishToHashnode({ ... }),
    publishToDevTo({ canonical_url: longevityaiUrl, ... }),
  ]);
}

The canonical_url parameter is critical: it tells Google that longevityai.nl is the original source. No duplicate-content penalty. The syndicated copies are tracked in the social_posts table to prevent double-posting on retry.

This blog you are reading right now? Originally written for longevityai.nl. Auto-posted to Hashnode and Dev.to via this exact pipeline.

Lessons Learned

1. Compliance is the moat. Anyone can scrape RSS feeds and rephrase them. Few people can pass an IGJ audit on the output. Build the gate first.

2. Cheaper models often write more naturally. Haiku writes Dutch health content with less corporate fluff than GPT-4o-mini. Test before assuming.

3. Deduplication is two-layer or it is broken. URL-hash + DB query check. Same article hits the same pipeline from multiple sources.

4. Canonical URLs > hiding. Syndicate openly with canonical_url. Hiding AI-generation crosses an ethical line and Google's 2024+ guidelines do not penalize transparent AI content anymore.

5. Fire-and-forget syndication. Hashnode/Dev.to failures should not break the main publish flow. Wrap in try/catch, log warnings, never crash.

What I Would Build Next

• LinkedIn syndication (waiting on API approval)
• Medium fallback for health-content audience (not just technical)
• Topic clustering so the cron only generates content where my lab/RAG has expertise
• Weekly digest emails auto-generated from the past 7 days of new blogs

The core insight: do not try to compete on content volume. Compete on the depth of the pipeline behind each piece. Quality gates, transparent sourcing, ethical syndication. The autopilot is not about more blogs. It is about every blog being defensible.

---

This article was originally published on Longevity AI. Visit the source for the full context, references and the live News Radar in action.

---

This article was originally published on Longevity AI. Visit the source for the full context, references and discussion.