# How to Vibe Code Your Own posterly (and Stop Paying for It)

> The AI-powered social media scheduler for creators and teams.

- Site: https://poster.ly
- Category: Social Media SaaS
- Verdict: **Serious undertaking** (38/100 vibecodeable)
- Estimated effort: 2-3 months of focused part-time work

## Verdict

Build a personal dashboard and local scheduler subset yourself, but keep paying for the service if you rely on 18 fully maintained social platform APIs.

The dashboard, calendar UI, and AI caption wrappers are straightforward to construct with modern AI coding tools. However, the true nightmare of a social scheduler is the relentless maintenance overhead of OAuth token refreshes, shifting API schemas across 18 networks, and configuring bulletproof asynchronous queues. For $15/mo, paying for the service spares you from endless API deprecation debugging.

### What you can't replicate

- Zero-maintenance OAuth connections across 18 third-party social networks
- Built-in partnership access to proprietary platform posting permissions
- Instant agency client trust and review history

## What it does

Plan, write, and schedule content across up to 18 social and publishing platforms from a single unified dashboard, with AI brand voice learning and Model Context Protocol (MCP) support.

### Core features

- Unified multi-platform content calendar
- AI caption generation with brand voice learning
- Asynchronous background queueing for timed posts
- Model Context Protocol (MCP) server integration
- Client approval workflows and guest review pages
- Social inbox for comments and direct messages
- Link-in-bio page hosting and analytics

## The business

### Pricing

- Starter: $7/mo — Supports up to 5 social accounts, 1 brand, 1 team seat, and unlimited standard posts.
- Pro: $15/mo — Most popular tier for growing creators and small teams.
- Power User: $25/mo — Advanced limits for power users and scaling creators.
- Agency: Custom — Top-tier plan for agency operations.

Founded 2024.
Team size: Solo-led.

## The hard parts

- Maintaining OAuth authentication tokens, rate limits, and changing API payloads across 18 distinct social platforms
- Implementing rock-solid asynchronous queueing with Redis and BullMQ to prevent dropped posts or double-publishing
- Building a secure Model Context Protocol (MCP) server enabling external AI agents to execute write operations programmatically
- Handling media conversions and aspect ratio adjustments for various video and image requirements per network

## How to vibe code posterly

### Prerequisites

- Node.js (free): Required runtime for Next.js full-stack development and backend worker scripts.
- GitHub (free): Source control and CI/CD integration repository hosting.

### Recommended AI tools

- Claude Code: Best-in-class multi-file agentic coding tool for scaffolding complex API integrations and database models.
- Cursor: Ideal code editor for fine-tuning UI views, calendar layouts, and component-level styling with real-time diff reviews.

### Stack

- Frontend: Next.js
- Backend: Next.js API routes with Redis worker queues
- Database: Turso
- Auth: better-auth
- Payments: Stripe
- Other: BullMQ for background processing, Resend for email verification links, Vercel AI SDK

### Hosting

- Vercel (Hosting the Next.js frontend and serverless API endpoints.): $0-20/mo
- Railway (Hosting persistent Redis workers required for reliable scheduled post queues.): ~$5/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize the Next.js application with TypeScript, Tailwind CSS, and configure Turso with better-auth tables and core relational models for brands, social accounts, posts, and scheduled queues.

```
Scialize a new Next.js project using Tailwind CSS and configure better-auth with Turso as the database. Create Prisma or Drizzle schema definitions for users, workspaces, connected_accounts (storing encrypted OAuth tokens), posts (with fields for title, content, media URLs, status, scheduled_at, and platform targets), and client_approvals. Ensure all foreign keys have proper cascading deletes and indexes on scheduled timestamps for fast queue polling.
```

2. **Unified Dashboard and Calendar UI** — Build the core command center featuring monthly, weekly, and list views for scheduled posts using drag-and-drop scheduling components.

```
Build a responsive Next.js dashboard layout with a collapsible sidebar and top nav. Implement a main content calendar view supporting month, week, and list filters. Use React components to display scheduled post cards color-coded by social platform icon (Instagram, X, LinkedIn, TikTok). Include quick action buttons for creating new posts, filtering by brand workspace, and viewing summary analytics counters for scheduled and published counts.
```

3. **Multi-Platform Composer and AI Brand Voice** — Construct the content composer supporting multi-platform targeting, character limit validations, and AI-assisted caption generation.

```
Create a multi-platform post composer component. It should allow selecting multiple target social accounts, provide a unified text area with live character limit indicators per network, and support media uploads. Integrate the Vercel AI SDK to add an 'AI Brand Voice' button that calls an API route, passing recent post history from Turso to generate an on-brand caption variant with American or British spelling rules.
```

4. **Asynchronous Queueing and Scheduler Engine** — Set up Redis and BullMQ on Railway to manage exact-minute post publishing with idempotent retry loops and error logging.

```
Configure a BullMQ worker backend running on Node.js connected to a Railway Redis instance. Implement a cron-style job producer that polls Turso for posts where scheduled_at <= NOW() and status = 'scheduled'. Create worker tasks that process posting payloads to simulated or real social APIs, handling rate limits with exponential backoff retries, setting status to 'published' on success, or capturing error logs and updating status to 'failed' if all retries exhaust.
```

5. **Model Context Protocol (MCP) Server** — Expose an authenticated Model Context Protocol (MCP) server so external AI coding assistants can query accounts and schedule posts programmatically.

```
Build an MCP (Model Context Protocol) server endpoint within the Next.js application using standard transport layers. Expose tools that allow authenticated external agents (like Claude Desktop or Cursor) to list connected social accounts, retrieve recent post analytics, and programmatically schedule new posts. Secure the endpoints with Bearer token authentication validated against workspace API keys.
```

6. **Client Approval Workflows and Polish** — Develop the white-label review portal enabling external clients to verify via email code and sign off on posts without a paid seat.

```
Implement a client approval portal accessible via secure tokenized links. When an agency sends posts for review, generate a guest view where the client enters their email, verifies via a 6-digit code sent via Resend, and views posts in a feed or calendar format. Add interactive controls for 'Approve', 'Request Changes', and 'Comment' that update the post status in Turso and trigger notification logs for the agency team.
```

### Cost vs paying

**Starting costs (one-time):**

- Custom domain name (optional): $12 one-time
- AI coding credits: $20 one-time
- Total: ~$32 one-time

**Ongoing costs (monthly):**

- Vercel Hobby/Pro hosting: $0-20/mo
- Railway Redis instance for BullMQ: $5/mo
- Turso database & Resend email: $0/mo
- Total: ~$10-25/mo

- Paying for the SaaS instead: $15/mo
- Build time: 45-60 hours
- AI tool credits: $20
- Break-even: Never (paying $15/mo is cheaper than the maintenance and infrastructure time)

## Sources

- [posterly Official Website & Features](https://poster.ly)
- [posterly Client Approval Workflow](https://poster.ly/features/client-approvals)
- [Smithery Registry: posterly MCP Server Specs](https://smithery.ai/server/awpthorp/posterly)