The Problem: Newsletter Platforms Trap You in a Corner

As a content creator or entrepreneur, you want to build an engaged audience through newsletters. But existing platforms force you into impossible trade-offs:

1. Substack and Beehiiv lock you into their branding—no custom domains without paying premium
2. Mailchimp and ConvertKit charge exorbitant fees once your list grows beyond 1,000 subscribers
3. Ghost requires self-hosting with DevOps expertise—database management, email delivery, SSL certificates
4. Enterprise platforms like HubSpot overwhelm you with features you'll never use
5. None of them provide content curation tools—you're copy-pasting links from browser tabs

I wanted to build something different: professional-grade newsletter infrastructure with Substack-level simplicity, plus tools that make content curation effortless.

The result: CuratedLetters, a multi-tenant platform built for creators who want full control without the complexity.

The Vision: Own Your Audience, Not Your Infrastructure

I set out to build CuratedLetters: a newsletter platform that handles the hard technical problems so creators can focus on content. The core principles:

The Tech Stack: Choosing the Right Tools

The Architecture: Multi-Tenancy Without the Complexity

Building a multi-tenant platform means handling thousands of independent newsletters on the same infrastructure. The architecture:

Request Flow: From Domain to Data

1. User visits newsletter.curatedletters.com
2. Next.js middleware extracts hostname, queries database for matching Newsletter record by custom domain or subdomain
3. If found and active, attach newsletter ID to request context; if suspended, show "Publication Paused" page
4. All subsequent database queries include WHERE newsletterId = ? clause
5. Load newsletter-specific branding (logo, colors, fonts) from database, apply to page template
6. Render SSR page with newsletter context—issues, subscriber count, social links, custom footer

This pattern provides complete data isolation between newsletters without database-per-tenant overhead. One PostgreSQL instance, thousands of newsletters, zero cross-tenant leakage.

Database Schema Design

The Prisma schema defines 20+ models. Core entities:

• Newsletter: Tenant entity with custom domain config, publication settings, branding
• Issue: Published newsletters with HTML content, send date, open/click tracking
• Subscriber: Email addresses with status (active, bounced, unsubscribed), engagement history
• Item: Curated content blocks with title, URL, description, AI summaries, categories
• Campaign: Email sending jobs with batch progress, success/failure counts
• SocialMediaIntegration: OAuth tokens for Twitter, LinkedIn, Reddit, Facebook
• NewsletterSocialMediaIntegration: Links newsletters to social accounts with posting config
• Post: Social media posts with status (scheduled, sent, failed), engagement metrics

Every query goes through Prisma's type-safe API. SQL injection is impossible. Missing WHERE clauses fail at compile time if TypeScript types don't match.

The Email Pipeline: Orchestrating AWS SES at Scale

Sending newsletters to 10,000 subscribers can't block a web request. The email pipeline decouples HTTP from delivery:

The Sending Workflow

When a user clicks "Send Newsletter", here's what happens:

1. Campaign Creation: API creates Campaign record with status: PENDING
2. Subscriber Batching: Query active subscribers (exclude bounced/unsubscribed), chunk into batches of 50
3. Queue Jobs: Push batches to BullMQ with retry config (3 attempts, exponential backoff)
4. Background Processing: Workers claim jobs, render HTML with personalization, call SES API
5. Progress Updates: Workers update campaign progress, emit real-time events to UI
6. SNS Webhooks: AWS sends bounce/complaint/open events back to /api/sns-notifications

The queue pattern ensures:

• Users don't wait for emails to send—instant UI response
• SES rate limits don't crash the app—jobs retry automatically
• Server restarts don't lose jobs—Redis persistence
• Failed batches get retried without manual intervention

DKIM Signing and Deliverability

Email providers (Gmail, Outlook) check sender reputation via SPF, DKIM, and DMARC records. The platform:

• Guides users through DNS setup (automated verification checks)
• Signs every email with custom DKIM private key (configured via DKIM_PRIVATE_KEY)
• Tracks hard bounces (invalid email) → immediate suppression
• Tracks soft bounces (mailbox full) → suppress after 3 attempts
• Tracks complaints (spam reports) → auto-unsubscribe

This maintains sender reputation, which directly impacts inbox placement. Poor deliverability means your newsletters go to spam—or don't arrive at all.

The Content Curation System: Stop Copy-Pasting from Browser Tabs

Newsletter curation is painful. You open 50 browser tabs, copy links to Notion, write summaries manually. CuratedLetters automates this:

Chrome Extension: One-Click Capture

Reading an article you want to share? Click the extension icon:

1. Extension scrapes page metadata (title, description, Open Graph image, author)
2. Sends to /api/chrome-extension/items with authentication token
3. API creates Item record linked to your newsletter
4. Item appears in your draft queue with option to edit or publish

No more copy-pasting URLs. No more switching between tabs and note apps. One click, content captured.

RSS Feed Automation

Follow your favorite blogs via RSS. Background jobs poll feeds every hour, parse new entries, create draft items automatically. You curate and publish—the platform handles collection. Deduplication by URL prevents the same article appearing twice.

AI-Generated Summaries with GPT-4o

Long articles need summaries. Writing them manually takes time. The platform calls OpenAI's API:

// API route: /api/description-generator
const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'Summarize articles in 2-3 sentences...' },
    { role: 'user', content: articleText }
  ]
})

// Return summary to frontend for approval/editing

Creators review AI summaries, edit if needed, publish. This cuts curation time from hours to minutes.

The Social Media Challenge: OAuth Across Four Platforms

Publishing a newsletter shouldn't mean manually posting to Twitter, LinkedIn, Reddit, and Facebook. But OAuth flows are different for each platform.

The OAuth Dance

Every platform follows the same pattern with unique quirks:

1. User clicks "Connect Twitter" → redirect to https://twitter.com/i/oauth2/authorize
2. User grants permissions → Twitter redirects back with authorization code
3. Backend exchanges code for access token + refresh token via /oauth2/token
4. Store tokens in SocialMediaIntegration table
5. Link integration to newsletter via NewsletterSocialMediaIntegration

Platform-Specific Quirks

• Twitter: API v2 requires PKCE flow, different token expiration than v1.1
• LinkedIn: Organization vs personal posting requires different permissions and API endpoints
• Reddit: 60 requests per minute rate limit, subreddit posting requires moderator approval
• Facebook: Page access tokens separate from user tokens, Graph API version migrations

Auto-Posting Features

Once connected, newsletters can auto-post:

• Immediately when issue publishes (configurable per platform)
• Scheduled at specific times (daily, every N days, custom schedule)
• To multiple targets (main profile, organization page, subreddit, group)

The platform handles token refresh, retry logic, and re-authentication emails when tokens expire.

The Challenges and Trade-Offs

The Results: From Hours to Minutes

The Developer Experience Lessons

What I'd Do Differently

1. App Router from Day One: The project uses Pages Router. App Router's React Server Components would simplify data fetching and reduce client bundle size.
2. GraphQL Instead of 60+ REST Endpoints: REST meant multiple API calls per page. A unified GraphQL API would reduce over-fetching and client complexity.
3. E2E Tests for Critical Flows: Email sending, OAuth, and billing webhooks need end-to-end tests. Playwright could simulate entire journeys.
4. Feature Flags for Gradual Rollouts: Shipping features to 100% of users at once is risky. LaunchDarkly or Flagsmith would enable A/B testing and gradual rollouts.

Inside CuratedLetters: A Visual Tour

AI-Powered Newsletter Builder

Get started in seconds with the AI Magic Tool—simply describe your newsletter topic and let GPT-4o generate a complete publication structure with content ideas and scheduling recommendations.

Content Curation Made Effortless

Collect items from RSS feeds, Chrome extension captures, and manual entries—all organized in one place with AI-generated summaries, status badges, and drag-and-drop issue assignment.

Publication Settings

Configure every aspect of your newsletter—custom domains, email settings, RSS feeds, social integrations, ads, and AI-powered summaries.

Smart Scheduling

Set publish frequency, send times, and enable auto-scheduling with AI-powered content curation and description generation.

Subscriber Management & Analytics

Track every subscriber with detailed engagement metrics—unique opens, clicks, referral counts, and subscription status. Prune inactive users and monitor list health in real-time.

Issue Statistics

Monitor open rates, click rates, delivery status, and engagement for every published issue.

Referral Rewards

Activate referral programs with custom rewards to incentivize subscriber growth.

Social Integrations

Connect Reddit, LinkedIn, Twitter, and Facebook for automatic cross-posting when issues publish.

Multi-Publication Dashboard

Manage multiple newsletters from one account—each with separate branding, subscribers, and settings. Switch between publications instantly and scale your content empire.

Revenue Tracking

Monitor earnings, revenue share progress, and payout status with gamified tasks to increase your share percentage.

Team Collaboration

Invite team members with role-based access (Owner, Admin, Contributor) and manage permissions for collaborative publishing.

Issue Management & Scheduling

View all issues (scheduled, draft, published) in a clean list view with dates, status indicators, and quick access to editing. Track your content pipeline from ideation to delivery.

Conclusion: Build for Real Users at Scale

CuratedLetters proves that a small team can build production-grade SaaS with the right architecture. Multi-tenancy, background jobs, OAuth integrations, and billing aren't just enterprise concerns—they're table stakes for modern platforms.

The key insights: decouple concerns early (web servers from workers), invest in type safety (Prisma + TypeScript catches bugs at compile time), and monitor everything (logs, queues, errors, analytics).

The platform handles complex workflows—email campaigns to thousands, OAuth token management, social media auto-posting, custom domains with SSL—while maintaining simplicity for creators. That balance is what engineering is all about.

Building platforms that scale requires discipline, but the patterns are repeatable. This is how you ship software that lasts.