Best Tech Stack for a Social Media Tool as a Solo Developer

Social media tools are a massive market. Buffer, Hootsuite, Later, Publer, Typefully - each started small and grew by solving a specific pain point for content creators and marketers. Whether you're building a scheduler, analytics dashboard, content repurposing tool, or link-in-bio solution, the technical patterns are similar: integrate with platform APIs, handle OAuth across multiple services, process media, and run scheduled tasks reliably.

Here's the stack that handles all of this without overwhelming a solo developer.

Recommended Stack at a Glance

Frontend: Next.js

Social media tools are dashboard-heavy applications. Users manage multiple accounts, create and schedule content, view analytics, and browse content calendars. Next.js with React gives you the component ecosystem to build these interfaces efficiently. The project sits at 139,595 GitHub stars and around 40 million npm downloads a week, and the current release on npm is 16.2.6, so the framework is about as battle-tested and well-supported as anything you can build on.

Key UI patterns you'll build:

• Content calendar - Drag-and-drop grid view of scheduled posts. Use a library like @dnd-kit (currently 6.3.1 on npm) for drag interactions.
• Post composer - Rich text editor with media upload, platform previews, and character count limits per platform.
• Analytics dashboard - Charts showing engagement over time. Use recharts or chart.js.
• Account management - Connect/disconnect social accounts via OAuth.

Next.js gives you server-side rendering for your marketing pages (important for SEO) while keeping the dashboard fully client-rendered for responsiveness. The app router's layout system is perfect for the sidebar + main content pattern that every SaaS dashboard uses.

Backend: Next.js API Routes + Worker Process

Your backend has two distinct responsibilities:

API Layer (Next.js API routes): Handle user requests - create posts, fetch analytics, manage accounts, process payments. These are synchronous request-response operations that fit the serverless model.

Worker Process (Railway): Handle scheduled jobs - publish posts at their scheduled time, sync analytics data from platforms, refresh OAuth tokens. These need to run on a schedule or from a queue, and they need to be reliable. A missed scheduled post is a broken promise to your user.

For the worker, run a Node.js process with BullMQ (backed by Redis) that processes jobs from a queue. Schedule jobs when users create a post such as "publish this to Twitter at 3pm EST on Tuesday." BullMQ supports delayed jobs natively, which makes this straightforward. It is a mature, actively maintained library at 8,943 GitHub stars, roughly 5.6 million npm downloads a week, and a current release of 5.77.6.

Database: PostgreSQL + Prisma

Your data model needs to handle multi-platform content elegantly. A single "post" from the user's perspective becomes multiple platform-specific posts with different text limits, media formats, and publishing statuses.

Core schema:

• users - Account and billing info
• social_accounts - Connected platforms with OAuth tokens (encrypted)
• posts - Parent post with content
• platform_posts - Per-platform versions with platform-specific text, status, published_at
• media - Uploaded images/videos linked to posts
• analytics - Engagement metrics synced from platforms

Prisma handles this relational model cleanly with type-safe queries. It is one of the most widely adopted Node ORMs at 46,031 GitHub stars and around 11.6 million npm downloads a week, with a current release of 7.8.0. Host on Neon (serverless Postgres) or Supabase. Neon's free plan gives each project 0.5 GB of storage, 100 compute-hours, and 5 GB of egress, which is plenty for early development. When you outgrow it, the Launch plan is consumption-based at $0.106 per compute-hour and $0.35 per GB-month of storage, so you pay for what the database actually uses.

Important: Encrypt OAuth tokens at rest. You're storing access to people's social media accounts. Use aes-256-gcm encryption with a key from environment variables. This isn't optional.

Queue and Scheduling: BullMQ + Redis

The scheduling system is the heart of a social media tool. It needs to:

1. Accept scheduled posts with precise timestamps
2. Execute at the right time (within seconds of the target)
3. Handle failures gracefully (retry on API errors, notify on permanent failure)
4. Scale to thousands of concurrent scheduled jobs

BullMQ handles all of this. When a user schedules a post, create a delayed job with the exact delay until publish time. BullMQ stores it in Redis and triggers the worker when the time arrives. Failed jobs get retried automatically with exponential backoff.

Run Redis on Railway alongside your worker process, or point BullMQ at a managed Redis like Upstash. Upstash's free Redis tier covers 500,000 commands a month with 256 MB of storage, and pay-as-you-go is $0.20 per 100,000 commands after that, so a small social media tool runs at or near zero on the queue side for a long time.

File Storage: Cloudflare R2

Social media tools handle a lot of images and videos. Users upload media, you potentially resize/optimize it for different platforms, and you need to serve it back in the composer and calendar views.

Cloudflare R2 with zero egress fees keeps your media storage costs predictable. Standard storage is $0.015 per GB-month, Class A operations (writes) are $4.50 per million and Class B operations (reads) are $0.36 per million, and egress to the internet is free. The free tier covers 10 GB-month of storage, 1 million Class A operations, and 10 million Class B operations a month, so the first chunk of usage costs nothing. Use signed URLs for upload (direct to R2 from the browser) and serve media through Cloudflare's CDN.

For image processing (resizing for different platform requirements), use Sharp in your worker process. It's fast and handles all common image formats, and it is one of the most-downloaded packages in the ecosystem at around 64.7 million npm downloads a week, 32,275 GitHub stars, and a current release of 0.34.5.

Auth: NextAuth.js with Platform OAuth

NextAuth.js (now part of the Auth.js project, 28,259 GitHub stars, with the next-auth package pulling around 3.2 million npm downloads a week and the v4 line currently at 4.24.14) handles both user authentication and social platform connections. Configure it with:

• Email/password or magic link for user login
• Twitter, Instagram, Facebook, LinkedIn, TikTok OAuth for platform connections

Each platform's OAuth flow has quirks. Twitter uses OAuth 2.0 with PKCE, Meta requires app review for Instagram permissions, LinkedIn has a separate marketing API scope. Budget time for getting each platform's OAuth right. It's the most tedious part of building a social media tool.

Nice-to-Haves

• Stripe for subscription billing (per-account or per-seat pricing). Standard online card processing is 2.9% plus 30 cents per successful domestic transaction.
• Sentry for error tracking (failed publishes need immediate visibility). The free Developer plan covers 5,000 errors a month, and the Team plan starts at $26/month (billed annually).
• Upstash for rate limiting (respect platform API rate limits). The same free Redis tier of 500,000 commands a month works for this.
• Resend for email notifications (post published, scheduling failed). The free plan sends 3,000 emails a month, capped at 100 a day, and the Pro plan is $20/month for 50,000 emails.
• OpenAI API for AI caption generation and content suggestions. gpt-4o-mini is cheap enough to leave on, at $0.15 per million input tokens and $0.60 per million output tokens, so a caption draft costs a fraction of a cent.

Monthly Cost Breakdown

All figures above were checked on 2026-05-30 and pricing changes often, so confirm current rates on each vendor's page before you budget. As you scale, the worker process will need more resources (more scheduled posts means more jobs), but this handles hundreds of active users comfortably.

Sources

All numbers in this post were checked on 2026-05-30.

• Next.js stars: https://github.com/vercel/next.js
• Next.js npm version and weekly downloads: https://www.npmjs.com/package/next
• Prisma stars: https://github.com/prisma/prisma
• Prisma npm version and weekly downloads: https://www.npmjs.com/package/prisma
• BullMQ stars: https://github.com/taskforcesh/bullmq
• BullMQ npm version and weekly downloads: https://www.npmjs.com/package/bullmq
• NextAuth.js / Auth.js stars: https://github.com/nextauthjs/next-auth
• next-auth npm version and weekly downloads: https://www.npmjs.com/package/next-auth
• Sharp stars: https://github.com/lovell/sharp
• Sharp npm version and weekly downloads: https://www.npmjs.com/package/sharp
• @dnd-kit/core npm version: https://www.npmjs.com/package/@dnd-kit/core
• Vercel pricing: https://vercel.com/pricing
• Railway pricing: https://railway.com/pricing
• Neon pricing: https://neon.com/pricing
• Cloudflare R2 pricing: https://developers.cloudflare.com/r2/pricing/
• Stripe pricing: https://stripe.com/pricing
• Sentry pricing: https://sentry.io/pricing/
• Upstash pricing: https://upstash.com/pricing
• Resend pricing: https://resend.com/pricing
• OpenAI API pricing (gpt-4o-mini): https://openai.com/api/pricing/

Conclusion

The best stack for a solo developer building a social media tool: Next.js for the dashboard and API, PostgreSQL with Prisma for data, BullMQ with Redis for reliable post scheduling, Cloudflare R2 for media storage, and a split deployment between Vercel (web) and Railway (workers).

The biggest challenge isn't the stack. It's the platform APIs. Each social network has different rate limits, content formats, media requirements, and OAuth flows. Pick one or two platforms to start with (Twitter/X and LinkedIn are the easiest to integrate), nail the scheduling and publishing reliability, and expand to more platforms once your core system is rock solid. Users will forgive a limited platform list, but they won't forgive missed scheduled posts.