If you're running a blog, you know the challenge: you write great content, but it only reaches people who visit your website. What if you could automatically share that same content across Dev.to, Medium, Hashnode, LinkedIn, and Hackernoon with a single command?

That's exactly what we built at Edesy. In this deep dive, I'll show you how we created a comprehensive blog cross-posting system that:

✅ Generates an RSS feed dynamically from our database
✅ Cross-posts to 5 platforms automatically
✅ Handles OAuth 2.0 for LinkedIn
✅ Manages canonical URLs for SEO
✅ Provides selective per-post control
✅ Includes dry-run testing mode

Total potential reach: 1+ billion people across all platforms.

The Problem

We were publishing high-quality technical content on our blog, but our reach was limited to:

Organic search traffic (takes time to build)
Direct visitors (requires brand awareness)
Social media shares (manual and inconsistent)

Meanwhile, platforms like Dev.to (1M+ developers), Medium (100M+ readers), LinkedIn (900M+ professionals), and Hackernoon (7M+ tech readers) had massive built-in audiences hungry for content.

The challenge: Manually cross-posting is tedious, time-consuming, and error-prone. We needed automation.

The constraint: We had to maintain SEO integrity with canonical URLs to ensure search engines knew our blog was the original source.

Architecture Overview

Our solution consists of three main components:

┌─────────────────────────────────────────────────────────────┐
│                     Blog Post (Markdown)                     │
│              content/blog/my-awesome-post.md                 │
└─────────────────────────────────────────────────────────────┘
                              ↓
                    Import to Database
                    (npm run blog:import)
                              ↓
┌─────────────────────────────────────────────────────────────┐
│                      PostgreSQL Database                     │
│                   (Prisma ORM with Post model)               │
└─────────────────────────────────────────────────────────────┘
                              ↓
                    ┌─────────┴──────────┐
                    ↓                    ↓
          ┌─────────────────┐   ┌────────────────┐
          │   RSS Feed      │   │  Cross-Post    │
          │ /blog/rss.xml   │   │    Script      │
          └─────────────────┘   └────────────────┘
                                         ↓
                    ┌────────────────────┼────────────────────┐
                    ↓         ↓         ↓         ↓           ↓
                 Dev.to    Medium   Hashnode  LinkedIn   Hackernoon

Component 1: RSS Feed Generation

We use Next.js 15's App Router to create a dynamic RSS feed at /blog/rss.xml.

File: /src/app/blog/rss.xml/route.ts

import { db } from '@/lib/db';
import { NextResponse } from 'next/server';
 
const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'https://edesy.in';
 
export async function GET() {
  try {
    // Fetch latest 50 published posts
    const posts = await db.post.findMany({
      where: { published: true },
      orderBy: { createdAt: 'desc' },
      take: 50,
      include: {
        author: true,
        categories: true,
      },
    });
 
    // Generate RSS 2.0 XML
    const rss = `<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Edesy Blog</title>
    <link>${SITE_URL}/blog</link>
    <description>Technical articles, tutorials, and insights from the Edesy engineering team</description>
    <language>en-us</language>
    <lastBuildDate>${new Date().toUTCString()}</lastBuildDate>
    <atom:link href="${SITE_URL}/blog/rss.xml" rel="self" type="application/rss+xml"/>
    ${posts.map(post => `
    <item>
      <title><![CDATA[${post.title}]]></title>
      <link>${SITE_URL}/blog/${post.slug}</link>
      <guid isPermaLink="true">${SITE_URL}/blog/${post.slug}</guid>
      <description><![CDATA[${post.excerpt || ''}]]></description>
      <pubDate>${new Date(post.createdAt).toUTCString()}</pubDate>
      <author>${post.author.email} (${post.author.name})</author>
      ${post.categories.map(cat => `<category>${cat.name}</category>`).join('\n      ')}
      <content:encoded><![CDATA[${post.content}]]></content:encoded>
    </item>
    `).join('\n')}
  </channel>
</rss>`;
 
    return new NextResponse(rss, {
      headers: {
        'Content-Type': 'application/xml',
        'Cache-Control': 'public, s-maxage=3600, stale-while-revalidate',
      },
    });
  } catch (error) {
    console.error('RSS generation error:', error);
    return new NextResponse('Error generating RSS feed', { status: 500 });
  }
}

Key features:

Dynamic generation from database (always up-to-date)
RSS 2.0 standard compliance
1-hour cache for performance
Full content with CDATA sections (handles HTML/markdown)
Category/tag support

Component 2: Cross-Posting Automation Script

The core of our system is a TypeScript script that handles publishing to all platforms.

File: /scripts/crosspost-blog.ts

import 'dotenv/config';
import { PrismaPg } from '@prisma/adapter-pg';
import { PrismaClient } from '@prisma/client';
import { Pool } from 'pg';
import * as fs from 'fs';
import * as path from 'path';
import matter from 'gray-matter';
 
const SITE_URL = process.env.NEXT_PUBLIC_SITE_URL || 'https://edesy.in';
 
// Database setup
const pool = new Pool({ connectionString: process.env.DATABASE_URL });
const adapter = new PrismaPg(pool);
const db = new PrismaClient({ adapter });
 
interface CrossPostResult {
  platform: string;
  success: boolean;
  url?: string;
  error?: string;
}
 
// Main cross-posting function
async function crosspostBlog(slug?: string, dryRun: boolean = false) {
  try {
    let posts;
 
    if (slug) {
      // Cross-post specific blog
      const post = await db.post.findUnique({
        where: { slug },
        include: { author: true, categories: true },
      });
 
      if (!post) {
        console.error(`❌ Post not found: ${slug}`);
        return;
      }
 
      posts = [post];
    } else {
      // Cross-post all blogs with crosspost enabled
      posts = await db.post.findMany({
        where: { published: true },
        include: { author: true, categories: true },
      });
    }
 
    for (const post of posts) {
      // Read frontmatter to check crosspost platforms
      const markdownPath = path.join(process.cwd(), 'content', 'blog', `${post.slug}.md`);
 
      if (!fs.existsSync(markdownPath)) {
        console.log(`⚠️  Skipping ${post.slug} - markdown file not found`);
        continue;
      }
 
      const fileContents = fs.readFileSync(markdownPath, 'utf8');
      const { data: frontmatter, content } = matter(fileContents);
 
      if (!frontmatter.crosspost || frontmatter.crosspost.length === 0) {
        console.log(`⏭️  Skipping ${post.slug} - no crosspost platforms specified`);
        continue;
      }
 
      console.log(`\n📝 Processing: ${post.title}`);
      console.log(`📍 Platforms: ${frontmatter.crosspost.join(', ')}`);
 
      if (dryRun) {
        console.log(`🧪 DRY RUN - Would cross-post to: ${frontmatter.crosspost.join(', ')}`);
        continue;
      }
 
      // Cross-post to each platform
      const results: CrossPostResult[] = [];
 
      for (const platform of frontmatter.crosspost) {
        let result: CrossPostResult;
 
        switch (platform.toLowerCase()) {
          case 'devto':
          case 'dev.to':
            result = await publishToDevTo(post, content);
            break;
          case 'medium':
            result = await publishToMedium(post, content);
            break;
          case 'hashnode':
            result = await publishToHashnode(post, content);
            break;
          case 'linkedin':
            result = await publishToLinkedIn(post, content);
            break;
          case 'hackernoon':
            result = await publishToHackernoon(post, content);
            break;
          default:
            result = {
              platform: platform,
              success: false,
              error: `Unknown platform: ${platform}`,
            };
        }
 
        results.push(result);
 
        // Rate limiting - wait 2 seconds between platforms
        await new Promise(resolve => setTimeout(resolve, 2000));
      }
 
      // Display results
      console.log('\n📊 Cross-posting results:');
      results.forEach(result => {
        if (result.success) {
          console.log(`  ✅ ${result.platform}: ${result.url}`);
        } else {
          console.log(`  ❌ ${result.platform}: ${result.error}`);
        }
      });
    }
 
    console.log('\n✨ Cross-posting complete!\n');
  } catch (error) {
    console.error('❌ Error:', error);
  } finally {
    await db.$disconnect();
    await pool.end();
  }
}

Component 3: Platform-Specific Integrations

Each platform has unique API requirements. Let's look at the most interesting ones:

Dev.to Integration (Simple REST API)

async function publishToDevTo(post: any, content: string): Promise<CrossPostResult> {
  const apiKey = process.env.DEVTO_API_KEY;
 
  if (!apiKey) {
    return {
      platform: 'Dev.to',
      success: false,
      error: 'DEVTO_API_KEY not found',
    };
  }
 
  try {
    const canonicalUrl = `${SITE_URL}/blog/${post.slug}`;
    const tags = post.categories.slice(0, 4).map((cat: any) => cat.name.toLowerCase());
 
    const response = await fetch('https://dev.to/api/articles', {
      method: 'POST',
      headers: {
        'api-key': apiKey,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        article: {
          title: post.title,
          published: true,
          body_markdown: content,
          tags: tags,
          canonical_url: canonicalUrl,
        },
      }),
    });
 
    const result = await response.json();
    return {
      platform: 'Dev.to',
      success: true,
      url: result.url,
    };
  } catch (error: any) {
    return {
      platform: 'Dev.to',
      success: false,
      error: error.message,
    };
  }
}

Key points:

Max 4 tags (Dev.to limit)
Canonical URL for SEO
Simple API key authentication

LinkedIn Integration (OAuth 2.0 + UGC Posts API)

LinkedIn is the most complex integration because it requires OAuth 2.0 authentication.

async function publishToLinkedIn(post: any, content: string): Promise<CrossPostResult> {
  const accessToken = process.env.LINKEDIN_ACCESS_TOKEN;
 
  if (!accessToken) {
    return {
      platform: 'LinkedIn',
      success: false,
      error: 'LINKEDIN_ACCESS_TOKEN not found',
    };
  }
 
  try {
    // Step 1: Get user profile (required for author URN)
    const userResponse = await fetch('https://api.linkedin.com/v2/userinfo', {
      headers: {
        'Authorization': `Bearer ${accessToken}`,
      },
    });
 
    if (!userResponse.ok) {
      throw new Error(`Failed to get user info: ${userResponse.statusText}`);
    }
 
    const userData = await userResponse.json();
    const authorUrn = `urn:li:person:${userData.sub}`;
    const canonicalUrl = `${SITE_URL}/blog/${post.slug}`;
 
    // Step 2: Create article share post
    const postData = {
      author: authorUrn,
      lifecycleState: 'PUBLISHED',
      specificContent: {
        'com.linkedin.ugc.ShareContent': {
          shareCommentary: {
            text: `${post.title}\n\n${post.excerpt}\n\nRead more: ${canonicalUrl}`,
          },
          shareMediaCategory: 'ARTICLE',
          media: [
            {
              status: 'READY',
              originalUrl: canonicalUrl,
              title: {
                text: post.title,
              },
              description: {
                text: post.excerpt || '',
              },
              ...(post.coverImage && {
                thumbnails: [
                  {
                    url: post.coverImage,
                  },
                ],
              }),
            },
          ],
        },
      },
      visibility: {
        'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC',
      },
    };
 
    const response = await fetch('https://api.linkedin.com/v2/ugcPosts', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${accessToken}`,
        'Content-Type': 'application/json',
        'X-Restli-Protocol-Version': '2.0.0',
      },
      body: JSON.stringify(postData),
    });
 
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`LinkedIn API error: ${errorText}`);
    }
 
    const result = await response.json();
    const linkedInUrl = `https://www.linkedin.com/feed/update/${result.id}`;
 
    return {
      platform: 'LinkedIn',
      success: true,
      url: linkedInUrl,
    };
  } catch (error: any) {
    return {
      platform: 'LinkedIn',
      success: false,
      error: error.message,
    };
  }
}

Key points:

OAuth 2.0 required (60-day token expiration)
Two API calls: userinfo → ugcPosts
UGC (User Generated Content) API for sharing
Article share format (not full article repost)
Requires author URN in format urn:li:person:{sub}

Hackernoon Integration (Editorial Review Workflow)

async function publishToHackernoon(post: any, content: string): Promise<CrossPostResult> {
  const apiKey = process.env.HACKERNOON_API_KEY;
 
  if (!apiKey) {
    return {
      platform: 'Hackernoon',
      success: false,
      error: 'HACKERNOON_API_KEY not found',
    };
  }
 
  try {
    const canonicalUrl = `${SITE_URL}/blog/${post.slug}`;
    const tags = post.categories.slice(0, 5).map((cat: any) => cat.name.toLowerCase());
 
    const response = await fetch('https://api.hackernoon.com/v0/stories', {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${apiKey}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({
        title: post.title,
        body: content,
        tags: tags,
        canonical_url: canonicalUrl,
        meta_description: post.excerpt,
        cover_image: post.coverImage || undefined,
        status: 'submitted', // Goes to editorial review
      }),
    });
 
    if (!response.ok) {
      const errorText = await response.text();
      throw new Error(`Hackernoon API error: ${errorText}`);
    }
 
    const result = await response.json();
 
    return {
      platform: 'Hackernoon',
      success: true,
      url: result.url || 'Submitted for review',
    };
  } catch (error: any) {
    return {
      platform: 'Hackernoon',
      success: false,
      error: error.message,
    };
  }
}

Key points:

Requires API key approval (1-7 days)
Editorial review workflow (24-72 hours)
Full article content posted
Max 5 tags
Status: submitted → editor review → approved

OAuth 2.0 Helper for LinkedIn

Getting LinkedIn tokens manually is tedious. We built a helper script that automates the OAuth flow.

File: /scripts/get-linkedin-token.ts

import 'dotenv/config';
import http from 'http';
import { URL } from 'url';
 
const CLIENT_ID = process.env.LINKEDIN_CLIENT_ID;
const CLIENT_SECRET = process.env.LINKEDIN_CLIENT_SECRET;
const PORT = 3333;
const REDIRECT_URI = `http://localhost:${PORT}/callback`;
 
if (!CLIENT_ID || !CLIENT_SECRET) {
  console.error('❌ LINKEDIN_CLIENT_ID and LINKEDIN_CLIENT_SECRET required');
  process.exit(1);
}
 
const server = http.createServer(async (req, res) => {
  const url = new URL(req.url || '', `http://localhost:${PORT}`);
 
  if (url.pathname === '/') {
    // Redirect to LinkedIn OAuth
    const authUrl = new URL('https://www.linkedin.com/oauth/v2/authorization');
    authUrl.searchParams.set('response_type', 'code');
    authUrl.searchParams.set('client_id', CLIENT_ID!);
    authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
    authUrl.searchParams.set('scope', 'profile email w_member_social openid');
 
    res.writeHead(302, { Location: authUrl.toString() });
    res.end();
  } else if (url.pathname === '/callback') {
    const code = url.searchParams.get('code');
 
    if (!code) {
      res.writeHead(400);
      res.end('No authorization code received');
      return;
    }
 
    try {
      // Exchange code for access token
      const tokenResponse = await fetch('https://www.linkedin.com/oauth/v2/accessToken', {
        method: 'POST',
        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
        body: new URLSearchParams({
          grant_type: 'authorization_code',
          code: code,
          client_id: CLIENT_ID!,
          client_secret: CLIENT_SECRET!,
          redirect_uri: REDIRECT_URI,
        }),
      });
 
      const tokenData = await tokenResponse.json();
      const accessToken = tokenData.access_token;
      const expiresIn = tokenData.expires_in;
 
      console.log('\n✅ Success! LinkedIn Access Token obtained');
      console.log(`📅 Expires in: ${Math.round(expiresIn / 86400)} days`);
      console.log('\n📝 Add to .env:');
      console.log(`LINKEDIN_ACCESS_TOKEN=${accessToken}\n`);
 
      res.writeHead(200, { 'Content-Type': 'text/html' });
      res.end(`
        <h1>✅ Success!</h1>
        <p>Access Token: <code>${accessToken}</code></p>
        <pre>LINKEDIN_ACCESS_TOKEN=${accessToken}</pre>
        <p>Expires in ${Math.round(expiresIn / 86400)} days</p>
      `);
 
      setTimeout(() => {
        server.close();
        process.exit(0);
      }, 2000);
    } catch (error: any) {
      console.error('❌ Error:', error.message);
      res.writeHead(500);
      res.end('Error getting token');
    }
  }
});
 
server.listen(PORT, () => {
  console.log(`🚀 OAuth server running at: http://localhost:${PORT}/`);
  console.log('Opening browser...\n');
 
  // Auto-open browser
  const open = (url: string) => {
    const cmd = process.platform === 'darwin' ? 'open' :
                 process.platform === 'win32' ? 'start' : 'xdg-open';
    require('child_process').exec(`${cmd} ${url}`);
  };
 
  setTimeout(() => {
    try {
      open(`http://localhost:${PORT}/`);
    } catch (error) {
      console.log('⚠️  Could not open browser. Visit the URL manually.');
    }
  }, 1000);
});

Usage:

npx tsx scripts/get-linkedin-token.ts

This automatically:

Starts a local web server
Opens LinkedIn OAuth in browser
Handles the callback
Exchanges code for access token
Displays token to add to .env

SEO Considerations: Canonical URLs

Critical: Without canonical URLs, cross-posting would hurt your SEO due to duplicate content penalties.

Every platform integration includes:

const canonicalUrl = `${SITE_URL}/blog/${post.slug}`;
 
// In the API request:
{
  canonical_url: canonicalUrl,
  // ... other fields
}

This tells search engines: "This content exists elsewhere, but this is the original source."

Result: Your blog gets the SEO credit, not the platforms.

Content Configuration: Frontmatter Control

Each blog post controls its own cross-posting via frontmatter:

---
title: "How to Build a REST API"
slug: "how-to-build-rest-api"
excerpt: "Learn to build production-ready REST APIs"
date: "2025-11-21"
published: true
categories: ["Backend", "API", "Tutorial"]
crosspost: ["devto", "medium", "linkedin"]  # ← Selective cross-posting
author:
  name: "Your Name"
  email: "[email protected]"
---
 
Your content here...

Options:

crosspost: ["devto"] - Only Dev.to
crosspost: ["linkedin", "hackernoon"] - Business + deep technical
crosspost: ["devto", "medium", "hashnode", "linkedin", "hackernoon"] - Maximum reach
Omit field entirely - No cross-posting

Setup Guide

1. Environment Variables

Create .env:

# Database
DATABASE_URL="postgresql://user:password@localhost:5432/blog"
 
# Site URL
NEXT_PUBLIC_SITE_URL="https://yourdomain.com"
 
# Dev.to
DEVTO_API_KEY="your_devto_api_key"
 
# Medium
MEDIUM_API_KEY="your_medium_integration_token"
 
# Hashnode
HASHNODE_API_KEY="your_hashnode_api_key"
HASHNODE_PUBLICATION_ID="your_publication_id"
 
# LinkedIn (OAuth)
LINKEDIN_CLIENT_ID="your_linkedin_client_id"
LINKEDIN_CLIENT_SECRET="your_linkedin_client_secret"
LINKEDIN_ACCESS_TOKEN="your_linkedin_access_token"
 
# Hackernoon (requires approval)
HACKERNOON_API_KEY="your_hackernoon_api_key"

2. Get API Keys

Dev.to: https://dev.to/settings/extensions → Generate API key

Medium: https://medium.com/me/settings/security → Integration tokens

Hashnode: https://hashnode.com/settings/developer → Personal access token

LinkedIn:

Create app at https://www.linkedin.com/developers/apps
Enable "Share on LinkedIn" product
Run: npx tsx scripts/get-linkedin-token.ts

Hackernoon:

Sign up at https://hackernoon.com/signup
Publish 1-2 articles manually (recommended)
Request API access from support
Wait for approval (1-7 days)

3. Install Dependencies

npm install gray-matter dotenv @prisma/client @prisma/adapter-pg pg

4. Add NPM Scripts

package.json:

{
  "scripts": {
    "blog:import": "npx tsx scripts/import-blog-markdown.ts",
    "blog:crosspost": "npx tsx scripts/crosspost-blog.ts",
    "blog:crosspost:dry-run": "npx tsx scripts/crosspost-blog.ts --dry-run"
  }
}

5. Usage

Write your blog post:

---
title: "My Awesome Post"
slug: "my-awesome-post"
crosspost: ["devto", "medium", "linkedin"]
---
 
Content here...

Import to database:

npm run blog:import

Test with dry run:

npm run blog:crosspost:dry-run

Cross-post for real:

npm run blog:crosspost

Cross-post specific article:

npx tsx scripts/crosspost-blog.ts --slug=my-awesome-post

Platform Strategy

Different platforms have different audiences. Here's our strategy:

Platform Audience Guide:

Dev.to: Tutorials and how-tos for developers - Post daily
Medium: Thought leadership for general tech audience - Post 2-3x per week
Hashnode: Developer blogs for developers - Post 2-3x per week
LinkedIn: Business insights for professionals - Post 1-2x per day max
Hackernoon: Deep technical content for tech enthusiasts - Post weekly

Recommended combinations:

Business/Product Content:

crosspost: ["linkedin", "medium"]

Technical Tutorials:

crosspost: ["devto", "hashnode"]

Deep Technical Analysis:

crosspost: ["hackernoon", "devto"]

Maximum Reach:

crosspost: ["devto", "medium", "linkedin"]

Results and Impact

After implementing this system, we achieved:

5x platform presence (1 blog → 5 platforms)
1+ billion potential reach across all platforms
95% time savings (5 minutes vs 2+ hours manual posting)
100% SEO safety with canonical URLs
Zero duplicate content issues

Engagement metrics (first month):

Dev.to: 10K+ views, 500+ reactions
Medium: 5K+ views, 200+ claps
LinkedIn: 2K+ impressions, 100+ engagements
Hackernoon: 3K+ views (after editorial approval)

Lessons Learned

1. OAuth Token Management is Critical

LinkedIn tokens expire after 60 days. Solutions:

Implement refresh token flow (production)
Set calendar reminder to regenerate (quick fix)
Monitor token expiration in code

2. Editorial Review Takes Time

Hackernoon submissions go through editorial review (24-72 hours). Don't expect instant publication.

3. Platform Limits Matter

Dev.to: Max 4 tags
Medium: Max 5 tags
LinkedIn: 500 posts/day per user
Hackernoon: Quality bar is high

Our script handles all limits automatically.

4. Rate Limiting is Essential

We added 2-second delays between platforms to avoid rate limits:

await new Promise(resolve => setTimeout(resolve, 2000));

5. Error Handling Must Be Robust

One platform failure shouldn't stop others:

try {
  result = await publishToPlatform(post);
} catch (error) {
  result = { success: false, error: error.message };
}
// Continue to next platform

Common Issues and Troubleshooting

"LinkedIn token expired"

Solution: Run npx tsx scripts/get-linkedin-token.ts to get a new token.

"Hackernoon unauthorized"

Solution: API key approval pending. Check email or contact [email protected].

"Medium: Post already exists"

Solution: Medium doesn't allow duplicate posts. Delete existing post or skip Medium for this article.

"Dev.to: Rate limited"

Solution: Wait 5 minutes, then try again. Our 2-second delay usually prevents this.

Advanced: CI/CD Automation

Want to automatically cross-post when you push to GitHub?

.github/workflows/crosspost.yml:

name: Cross-Post Blog
 
on:
  push:
    branches: [main]
    paths:
      - 'content/blog/**'
 
jobs:
  crosspost:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-node@v3
        with:
          node-version: '18'
      - run: npm install
      - run: npm run blog:import
      - run: npm run blog:crosspost
        env:
          DATABASE_URL: ${{ secrets.DATABASE_URL }}
          DEVTO_API_KEY: ${{ secrets.DEVTO_API_KEY }}
          MEDIUM_API_KEY: ${{ secrets.MEDIUM_API_KEY }}
          HASHNODE_API_KEY: ${{ secrets.HASHNODE_API_KEY }}
          HASHNODE_PUBLICATION_ID: ${{ secrets.HASHNODE_PUBLICATION_ID }}
          LINKEDIN_ACCESS_TOKEN: ${{ secrets.LINKEDIN_ACCESS_TOKEN }}
          HACKERNOON_API_KEY: ${{ secrets.HACKERNOON_API_KEY }}

Result: Push a new blog post → automatic cross-posting to all platforms!

Conclusion

Building a blog cross-posting system is a one-time investment that pays dividends forever. With this implementation, you can:

✅ Write once, publish everywhere
✅ Reach 1+ billion people across platforms
✅ Maintain SEO integrity with canonical URLs
✅ Save hours of manual work every week
✅ Selectively control distribution per post

Total implementation time: ~8 hours Time saved per post: ~2 hours Break-even point: After 4 blog posts

The complete source code for this implementation is available in our blog cross-posting documentation.

Next Steps

Set up your API keys for each platform
Test with a dry run to ensure everything works
Cross-post your first article and monitor the results
Automate with CI/CD for hands-off publishing
Track engagement across platforms to refine your strategy

Happy cross-posting! If you have questions or need help implementing this, feel free to reach out in the comments below.

Want to see this in action? This very blog post was cross-posted using the system described above! Check your preferred platform to see it live.

Building an Automated Blog Cross-Posting System: From One Platform to Five

The Problem

Architecture Overview

Component 1: RSS Feed Generation

Component 2: Cross-Posting Automation Script

Component 3: Platform-Specific Integrations

Dev.to Integration (Simple REST API)

LinkedIn Integration (OAuth 2.0 + UGC Posts API)

Hackernoon Integration (Editorial Review Workflow)

OAuth 2.0 Helper for LinkedIn

SEO Considerations: Canonical URLs

Content Configuration: Frontmatter Control

Setup Guide

1. Environment Variables

2. Get API Keys

3. Install Dependencies

4. Add NPM Scripts

5. Usage

Platform Strategy

Results and Impact

Lessons Learned

1. OAuth Token Management is Critical

2. Editorial Review Takes Time

3. Platform Limits Matter

4. Rate Limiting is Essential

5. Error Handling Must Be Robust

Common Issues and Troubleshooting

"LinkedIn token expired"

"Hackernoon unauthorized"

"Medium: Post already exists"

"Dev.to: Rate limited"

Advanced: CI/CD Automation

Conclusion

Next Steps

Share

Related Articles

Add Multiple Domains to Coolify Applications Without Redeployment Using Traefik File Provider

Fixing OAuthAccountNotLinked Error in NextAuth.js

Voicebot in Healthcare 2025: Complete Guide to AI Voice Agents for Hospitals & Clinics

Stay Updated