Why I Built A Developer Platform Instead Of Just Using Dev.to

For years, whenever I finished a technical article, I had a routine: paste the Markdown into Dev.to, hit publish, and watch the views roll in. It was simple. Dev.to has a fantastic community, great distribution, and it's undeniably one of the best places for developers to share knowledge.

But over time, a lingering frustration started to set in.

I realized I was building someone else's domain authority. I was locked into their editor, their analytics, and their feature set. If I wanted to add a custom email capture, integrate AI tooling, or do deep data analysis on my audience, I couldn't. I was a guest in someone else's house.

That frustration led to an "aha!" moment: What if I treated third-party platforms purely as distribution channels, and built my own platform as the canonical home for my content?

That's how ZyVOP was born. It's a custom-built developer platform with a Next.js frontend, a NestJS backend, and a Groq AI integration for content intelligence. Here is the story of why I built it, the business case for doing so, and the technical deep dive into how it works.

The Business Case: True Ownership and Syndication

If you're manually cross-posting or giving away your canonical URLs to Dev.to, ZyVOP solves both problems.

When you publish exclusively on a third-party platform, your data is siloed. With ZyVOP, the primary focus is True Data Ownership.

Instead of choosing one platform, ZyVOP acts as the central hub. I write the article once using a custom Tiptap editor (with support for KaTeX math and Mermaid diagrams), and ZyVOP automatically syndicates it out. Because it originates on my domain, search engines recognize ZyVOP as the canonical source.

But it goes beyond just posting articles. Owning the platform allowed me to build an entire ecosystem around the user:

• Custom Notifications: Integration with Brevo for fine-grained email digests, comment alerts, and automated re-engagement flows.

• AI Integration: Native hooks to Groq for AI-assisted writing and content enrichment.

• Internal Intelligence: Instead of relying on basic view counts, owning the platform allows me to integrate Groq AI for deep content intelligence, suggesting relevant tags and tracking cross-channel engagement to help authors build their audience organically.

• Enterprise-grade Security: Implementing Two-Factor Authentication (2FA) with backup codes — a feature you rarely get out-of-the-box on simple blogging platforms.

The Technical Deep Dive

Building a platform that can parse rich text, syndicate to multiple APIs, and run data intelligence requires a robust stack. Let's look under the hood.

A Powerful Backend Entity (NestJS & PostgreSQL)

In ZyVOP, the user is more than just an email and password. Because the platform acts as a syndication engine, the User entity (built with TypeORM and GraphQL) holds the keys to the entire developer ecosystem.

Here's a look at how we structure integrations in our backend:

// backend/src/modules/users/entities/user.entity.ts  
@Entity('users')  
export class User {  
  @PrimaryGeneratedColumn('uuid')  
  id!: string;  
  
  // Syndication API Keys  
  @Column({ type: 'varchar', nullable: true })  
  devToApiKey?: string | null;  
  
  @Column({ type: 'varchar', nullable: true })  
  hashnodeApiKey?: string | null;  
  
  @Column({ type: 'varchar', nullable: true })  
  mediumApiKey?: string | null;  
  
  // AI Integrations  
  @Column({ type: 'varchar', nullable: true })  
  groqApiKey?: string | null;  
  
  // Custom Notifications  
  @Column({ type: 'boolean', default: true })  
  emailUpdates!: boolean;  
  
  @Column({ type: 'boolean', default: true })  
  weeklyDigest!: boolean;  
  
  // Security  
  @Column({ type: 'boolean', default: false })  
  twoFactorEnabled!: boolean;  
}  
  

This entity allows a single user to manage their entire digital presence across the web from one dashboard.

The Custom HTML-to-Markdown Parser

One of the hardest parts of syndication is dealing with different Markdown flavors. ZyVOP's frontend editor (Tiptap) outputs rich HTML, but platforms like Dev.to require very specific Markdown.

Instead of relying on generic libraries that often break code blocks or custom formatting, I built a custom parser (html-to-markdown.js) using regex to gracefully downgrade HTML into Dev.to-compatible Markdown, injecting the canonical URL at the end:

function htmlToDevToMarkdown(html, canonicalUrl) {  
    if (!html) return '';  
    let text = html;  
  
    // Preserve code blocks gracefully  
    text = text.replace(/<pre><code[^>]*>([\s\S]*?)<\/code><\/pre>/gi, (_, code) => `\n\`\`\`\n${decodeHtml(code)}\n\`\`\`\n`);  
    text = text.replace(/<code>([\s\S]*?)<\/code>/gi, '`$1`');  
  
    // Convert headers, bold, and links  
    text = text.replace(/<h2[^>]*>([\s\S]*?)<\/h2>/gi, '## $1\n');  
    text = text.replace(/<strong>([\s\S]*?)<\/strong>/gi, '**$1**');  
    text = text.replace(/<a[^>]*href="([^"]*)"[^>]*>([\s\S]*?)<\/a>/gi, '[$2]($1)');  
  
    // Clean up remaining tags  
    text = text.replace(/<[^>]+>/g, '');  
    text = decodeHtml(text);  
  
    // Inject Canonical Source  
    text += `\n\n---\n\n*Originally published on [ZyVOP](${canonicalUrl})*`;  
    return text;  
}  
  

Together, these two layers — the backend entity and the parser — form the core of ZyVOP's syndication engine.

The Architecture of ZyVOP

To visualize how all these pieces fit together, here is the architecture of the ZyVOP ecosystem:

flowchart TD  
    %% Core Entities  
    Author([Author])  
    Reader([Reader])  
  
    %% Frontend Application  
    subgraph Frontend [Next.js App]  
        Editor[Tiptap Rich Editor]  
        UI[Tailwind UI]  
        Apollo[Apollo GraphQL]  
    end  
  
    %% Backend Application  
    subgraph Backend [NestJS Backend]  
        API[GraphQL API]  
        Auth[Auth & 2FA Service]  
        Syndication[Syndication Engine]  
    end  
  
    %% Data Persistence  
    DB[(PostgreSQL)]  
  
    %% External Ecosystem  
    subgraph External [Syndication & Ecosystem]  
        DevTo[Dev.to]  
        Hashnode[Hashnode]  
        Medium[Medium]  
        Bluesky[Bluesky]  
        Brevo[Brevo Mailing]  
    end  
  
    %% Intelligence Layer  
    subgraph IntelligenceLayer [Intelligence Layer]  
        Analytics[Internal Analytics]  
        Groq[Groq AI]  
    end  
  
    %% Routing  
    Author --> Editor  
    Reader --> UI  
    Editor --> Apollo  
    UI --> Apollo  
  
    Apollo <--> API  
    API <--> Auth  
    API <--> Syndication  
    Auth <--> DB  
    Syndication <--> DB  
  
    %% Outbound Integrations  
    Auth --> Brevo  
    Syndication -.->|Cross-Post| DevTo  
    Syndication -.->|Cross-Post| Hashnode  
    Syndication -.->|Cross-Post| Medium  
    Syndication -.->|Cross-Post| Bluesky  
  
    %% Intelligence  
    Syndication <--> Analytics  
    API <--> Groq  
  

Conclusion

Building a developer platform from scratch isn't for the faint of heart. It means maintaining your own infrastructure, dealing with SEO, managing Postgres migrations, and parsing messy HTML.

ZyVOP isn't just a blog — it's a syndication engine that cross-posts to Dev.to, Hashnode, Medium, and Bluesky in one click, with canonical URLs, 2FA, and AI tooling built in. I still love Dev.to. I just don't live there anymore.

ZyVOP is open to early writers — publish your first post here.

Originally published on ZyVOP

???? For more articles like this, subscribe to the ZyVOP newsletter!