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

> The unified social media API for builders

- Site: https://outstand.so
- Category: Developer Tool / SaaS API
- Verdict: **Serious undertaking** (52/100 vibecodeable)
- Estimated effort: 4-6 weeks of part-time work

## Verdict

Build a personal subset with a single upstream platform or keep paying; wrapping 11 volatile social APIs requires maintaining an engineering maintenance treadmill.

While a solo dev can vibecode the database schema, Express/Hono backend, and a couple of platform adapters in a few weeks, maintaining 11 distinct upstream APIs (Meta, X, TikTok, LinkedIn, etc.) with their differing rate limits, OAuth token refreshes, and breaking payload changes is a relentless maintenance trap. If you just want to post across channels, paying $19/mo is radically cheaper than debugging upstream API changes every month.

### What you can't replicate

- Upstream stability across 11 volatile third-party social network APIs
- Established production uptime history and webhook delivery infrastructure
- Pre-existing review and compliance approvals from social network developer portals

## What it does

Developer-first unified social media API and MCP server aggregating 11 major social platforms into a single API endpoint and data schema.

### Core features

- Unified JSON data schema across 11 platforms
- OAuth account connection flow and credential vault
- Two-step presigned URL media processing (R2 storage)
- Async posting queue with retry and backoff logic
- Idempotent post creation (Idempotency-Key support)
- Cross-platform analytics aggregation
- Remote MCP server with 27 tools for AI agent publishing
- Webhook event distribution for delivery outcomes

## The business

### Pricing

- Base Tier: $19/mo — Includes 3,000 posts per month and unlimited connected social accounts.
- Overage Tier: $0.005 - $0.007 / post — Pay-as-you-go overage pricing based on monthly volume.

Founded 2025.
Team size: 1-5.

## The hard parts

- Maintaining 11 distinct upstream social network integrations with volatile API changes
- Managing token refresh lifecycles and encrypted multi-tenant credential storage
- Handling platform-specific rate limits and preventing duplicate posts during network failures
- Implementing durable job queues for asynchronous scheduling across timezone boundaries

## How to vibe code Outstand

### Prerequisites

- Node.js (free): Runtime for the TypeScript backend service and MCP server
- GitHub (free): Repository hosting and deployment triggers

### Recommended AI tools

- Claude Code: Best-in-class multi-file scaffolding and handling complex backend API glue logic
- Cursor: Ideal for inspecting API request/response diffs and editing TypeScript handlers

### Stack

- Frontend: Next.js
- Backend: Hono (TypeScript on Node.js)
- Database: Turso
- Auth: better-auth
- Payments: none
- Other: Vercel AI SDK, Cloudflare R2

### Hosting

- Fly.io (Running the backend API server and background scheduler workers): $5/mo
- Cloudflare (R2 object storage for presigned media uploads and CDN): $0/mo

### Build guide

1. **Project Scaffolding and Database Schema** — Initialize a TypeScript backend with Hono, Turso for SQLite storage, and better-auth for API key generation.

```
Scaffold a new TypeScript backend project using Hono and Drizzle ORM configured for Turso. Create database tables for organizations, api_keys, social_accounts (storing encrypted tokens, network name, account metadata), posts (storing content, scheduled_at, published_at, idempotency_key), and post_containers (for multi-image/thread payloads). Implement authentication middleware that reads the Authorization: Bearer <API_KEY> header, validates it against the api_keys table, and injects the organization ID into the request context. Ensure proper error handling returning standard 401 JSON payloads for missing or invalid keys.
```

2. **OAuth Credential Vault and Social Account Connection** — Implement OAuth redirect endpoints and credential vault storage for connecting social networks.

```
Build social account connection endpoints in Hono. Create POST /v1/social-accounts/{network}/{orgId} that initiates OAuth redirects for X, LinkedIn, and Meta platforms, and a POST endpoint for Bluesky app passwords. Store returned OAuth access tokens, refresh tokens, and expiration timestamps securely encrypted in the database. Implement GET /v1/social-accounts to list connected accounts filtered by organization ID, and DELETE /v1/social-accounts/{id} to disconnect accounts and revoke local tokens.
```

3. **Presigned URL Media Processing Pipeline** — Implement the two-step presigned upload workflow targeting Cloudflare R2 storage.

```
Implement the media upload pipeline using S3-compatible presigned URLs pointing to Cloudflare R2. Create POST /v1/media/upload that accepts filename and content_type, generates a unique media ID, and returns a PUT presigned upload URL with an expiration window. Create POST /v1/media/{id}/confirm to verify file size and activate the media record, returning a public CDN URL. Store media records with a status enum (pending, active, expired) and ensure cleanup workers remove unconfirmed items after 60 days.
```

4. **Unified Post Creation and Idempotency Engine** — Build the unified post creation endpoint with multi-platform fan-out and idempotency tracking.

```
Build POST /v1/posts/ supporting unified post creation across multiple target accounts. Parse incoming JSON bodies containing containers (content and media arrays) and account specifiers (IDs, network names, or usernames). Implement idempotency checking via the Idempotency-Key request header: cache responses for 24 hours, return cached results with Idempotency-Replayed: true on retry, return 409 if a request is currently in flight, and return 422 if the key is reused with a differing body. For immediate posts, trigger asynchronous background dispatch tasks to upstream platform APIs.
```

5. **Scheduler and Background Worker Pipeline** — Implement a polling worker that processes scheduled posts when their timestamp arrives.

```
Implement a background cron worker that runs every minute to query the posts table for records where scheduled_at <= NOW() and published_at IS NULL. For each due post, fan out execution to the respective platform adapter handlers (X API, LinkedIn API, etc.), handle per-platform rate limits with exponential backoff and retries, capture native platform post IDs or error messages into the per-account result array, and update published_at once processing concludes.
```

6. **Model Context Protocol (MCP) Server Integration** — Expose an authenticated Model Context Protocol server enabling AI agents to interact with social endpoints.

```
Implement a remote Model Context Protocol (MCP) server endpoint using the Model Context Protocol SDK in TypeScript. Expose executable tools including create_post, list_posts, get_post_analytics, list_social_accounts, and upload_media. Ensure the MCP server validates API keys provided in the initialization handshake, translates LLM natural language parameters into standard internal API service calls, and returns clean, structured markdown tool outputs for AI coding assistants like Claude and Cursor.
```

### Cost vs paying

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

- Domain name: $12
- Developer API app approvals (Meta/X developer accounts): $0
- Total: ~$12 one-time

**Ongoing costs (monthly):**

- Fly.io backend compute: $5/mo
- Cloudflare R2 storage: $0/mo
- Total: ~$5/mo

- Paying for the SaaS instead: $19/mo
- Build time: 45-60 hours
- AI tool credits: $20
- Break-even: Never (purely for learning and fun)

## Sources

- [Outstand Official Website & Documentation Hub](https://outstand.so)