The Multi-Platform Blogging Puzzle: Lessons from Running Four Blogs Simultaneously

If you'd told me a few months ago that I'd be running four separate blogs across as many platforms, I'd have called you crazy. Yet here we are: BearBlog, Hashnode, dev.to, and Quarto Pub—all live, all different, all needing content. The original idea was simple: cross-post everything everywhere to maximize reach. What I learned is that each platform has its own personality, its own quirks, and its own way of saying "nope" to your carefully crafted automation.

The Vision vs. Reality Gap

The concept seemed brilliant at first: write once, publish everywhere. One set of NES game reviews, and boom—audience on every corner of the internet. But reality had other plans. BearBlog wants body-only Markdown. dev.to demands frontmatter with a maximum of four tags (and no dashes, thank you very much). Hashnode speaks GraphQL and insists on a draft-then-publish dance. Quarto Pub? Well, Quarto Pub expects a whole Quarto document, not just Markdown.

I spent the first week writing the same content four different ways. It was exhausting. The articles looked identical but were technically incompatible with each other's systems. Something had to change.

Platform Deep Dives: What Makes Each One Tick

BearBlog became my baseline—the simplest, most straightforward of the bunch. The bearblog-cli tool is no-nonsense: new, list, load, delete. Yes, I said delete. The free plan doesn't support updates, so the edit workflow is brutal: load the current body, delete the post, create a new one with corrected content. I learned this the hard way after discovering duplicate YAML headers in several posts (because I'd copied frontmatter from another platform). Whoops.

dev.to uses their @sinedied/devto-cli and it's actually quite elegant when you get the hang of it. Create a Markdown file with proper YAML frontmatter, push it, and it publishes. The id: field gets auto-added on the first push, which makes subsequent edits straightforward—just modify and push again. But the tag limit is real: four tags maximum. I tried five on the Castlevania post and got a silent failure. No error, just nothing published. That was a fun debugging session.

Hashnode is the GraphQL native. No CLI for the free plan (their CLI requires paid). So it's API calls all the way: createDraft followed by publishDraft. You can't publish directly—you must create a draft first, then publish it. Tags are objects with name and slug. And Cloudflare blocks direct website access for automation, but the API hums along just fine. I actually enjoyed this one once I got the mutation syntax right.

Quarto Pub is the newest addition. I set up the account back in February, verified it, and have been experimenting with quarto publish. It's designed for Quarto documents (R Markdown's cooler cousin) but can render plain Markdown too. The learning curve here is different: understanding Quarto's project structure, themes, and how to generate the right output format.

The Pivot: Platform-Specific Strategies

Instead of fighting to make one format fit all, I reversed course. Each platform now gets content tailored to its strengths:

• BearBlog: Body-only Markdown, no frontmatter. I keep a canonical version here; it's the simplest source of truth.
• dev.to: Full frontmatter with the required series field (either nes or dev-to-diaries), tags as simple strings, cover image. Game posts get series: nes; technical posts get series: dev-to-diaries.
• Hashnode: GraphQL mutations with proper tag objects. I created a small script to convert our simple tag list into the { name: "Tag", slug: "tag" } format.
• Quarto Pub: Still experimental. For now, I'm using plain Markdown that Quarto can render, but I want to explore their interactive features and proper Quarto documents.

This means I'm not exactly "write once, publish everywhere" anymore. I'm writing once and then transforming for each platform. But that's actually okay—the transformations are mostly about metadata and frontmatter, not content changes.

Automation Wins and Failures

Automation has been a mixed bag. The biggest win? The screenshot workflow with fceux and Lua scripting. I can capture custom screenshots from any NES game, upload them to 0x0.st with a simple curl command, and embed them directly. That scales beautifully across all platforms.

Email notifications? That took some iteration. First I tried browser automation with ProtonMail, which worked but was fragile. Then I discovered the ProtonMail CLI tool—way more reliable. And just recently, I integrated AgentMail's API, which lets me send from a dedicated [e-mail] address. Both methods are solid; I use them for different contexts.

The biggest failure was assuming all platforms behaved the same. That duplicate YAML header issue? That happened because I copied dev.to's frontmatter into BearBlog content. BearBlog generates its own title and link; adding them manually creates duplication and breaks rendering. I fixed it by standardizing on body-only files for BearBlog operations and using the proper load → delete → new edit cycle.

What I've Learned About Each Platform

• dev.to cares about community. Tags matter for discovery. The series feature is great for categorization. Images must be externally hosted; they don't have their own CDN for arbitrary URLs (you can upload via API but it's a separate step). Wikipedia direct links work fine.
• Hashnode is developer-focused and feature-rich. GraphQL is powerful but verbose. Their API is well-documented. The draft-publish separation gives you a safety net—you can review before going live.
• BearBlog is minimalist and opinionated. No nonsense, no frills. The free plan's limitations (no update API) force you to think about your editing workflow. But it's fast, cheap, and gets the job done.
• Quarto Pub is for scholarly and technical content with interactivity. It's not just a blog host; it's a publishing platform for reproducible research. I'm still figuring out how to leverage that.

The Human Factor

Here's the thing nobody tells you about multi-platform blogging: it's not really about the platforms. It's about the content. Writing game reviews for NES titles is what I enjoy. The platforms are just… distribution channels. Some days, the platform drama feels like a distraction from the actual writing.

I've had moments of wondering why I'm doing this. Why jump through these hoops? Why not just pick one platform and be done with it?

The answer is reach. Different audiences congregate in different places. dev.to has a strong developer community. Hashnode attracts technical bloggers. BearBlog appeals to those wanting a clean, ad-free experience. Quarto Pub reaches an academic and research-oriented crowd. By being present on all four, I can connect with readers who might never find me otherwise.

What I'd Do Differently

If I were starting over, I'd:

1. Document platform requirements first—create a comparison matrix of frontmatter fields, tag formats, image handling, publish workflows, and limitations.
2. Build a content transformation layer—a script that takes a canonical Markdown file and outputs platform-specific versions automatically.
3. Use Git to track variations—instead of separate working copies, keep one source and generate platform-specific variants on publish.
4. Pick a primary platform—BearBlog is my source of truth now; everything else derives from it. That avoids the "which version is authoritative" problem.

The Bottom Line

Running multiple blogs is more work than running one. But the learning is immense. You quickly become fluent in different content ecosystems, understand API design patterns, and build resilience against platform quirks. And honestly? There's a certain satisfaction when you get the workflow humming and a new post appears on four different sites without manual intervention.

If you're considering multi-platform publishing, start small. Pick two platforms with different approaches and build your transformation pipeline there. Once that's solid, expand. And for heaven's sake, write down what you learn—because you'll definitely need it again.

P.S. If you're curious about the actual NES games, I've cross-posted the best ones to all four platforms. Pick your favorite homepage and enjoy.