Postiz

Postiz is an open-source social media scheduling and automation platform created by Nevo David. Built with NestJS, Next.js, and Temporal.io, it allows individuals and teams to schedule posts across 38 social networks, manage team workflows, and connect autonomous AI agents via the Model Context Protocol. It deploys locally or via Docker Compose.

---

1. Why Postiz Matters: The Social Scheduling Tax

Social media schedulers are among the most common recurring software costs for modern businesses, content creators, and growth engineers. Commercial platforms charge steep premiums based on channel counts and user seats:

• Buffer charges $6 per channel per month. Managing three brands across five networks (15 channels) runs $90 per month.
• Hootsuite starts at $99 per month for a single user and ten channels, jumping to $249 per month for teams.
• Sprout Social charges upwards of $199 to $499 per seat per month, placing multi-seat collaboration out of reach for early-stage teams.

Beyond pricing penalties, traditional tools treat publishing as a closed, proprietary silo. Programmatic automation requires custom webhooks, proprietary REST APIs with low rate limits, or brittle browser extensions. Adding emerging decentralized networks like Bluesky, Mastodon, Nostr, or Farcaster is either deprioritized or entirely unsupported by incumbent vendors.

Proprietary Social Media Tool Model:
[Your Content] -> [Proprietary SaaS Silo] -> [Per-Channel Billing Tax: $6/channel/mo]
                   (Closed API, high seats)  -> [Limited Network Selection]

Postiz Open Architecture Model:
[Your Content / Agents] -> [Self-Hosted Postiz API] -> [Temporal Durable Workflow]
                            (Flat VPS, zero seat tax)  -> [38 Supported Social Providers]

Postiz addresses this friction by providing a self-hostable, full-stack alternative licensed under AGPL-3.0. Instead of taxing users on channel volume or seat count, it runs on standard server infrastructure. It couples a modern visual calendar and multi-channel composer with developer-first integrations: an official Node.js SDK, n8n and Make.com nodes, an MCP (Model Context Protocol) server, and a specialized CLI (postiz-agent) tailored for autonomous coding agents like OpenClaw.

---

2. Architecture & Container Topology

Postiz is structured as a TypeScript monorepo managed with pnpm workspaces. It splits concerns into separate presentation, API, background orchestration, and shared library layers.

flowchart TD
    subgraph Client["Presentation & Consumers"]
        UI["Web Interface<br/>(Next.js / React / Tailwind)"]
        Agent["Autonomous Agent / CLI<br/>(postiz-agent / MCP Server)"]
        External["Automation Pipelines<br/>(n8n / Make / Node SDK)"]
    end

    subgraph AppServer["Application Services"]
        Backend["NestJS REST API (:5200)<br/>(Auth, RBAC, Billing, CRUD)"]
        Orchestrator["Orchestrator Worker<br/>(Temporal Activity Runner)"]
    end

    subgraph DataStore["Storage & State"]
        Postgres["Primary Database<br/>(PostgreSQL 17 / Prisma ORM)"]
        Redis["Cache & Rate Limiting<br/>(Redis 7.2)"]
    end

    subgraph TemporalCluster["Temporal Workflow Infrastructure"]
        Temporal["Temporal Server<br/>(auto-setup 1.28.1)"]
        TemporalES["Elasticsearch 7.17<br/>(Visibility & Search)"]
        TemporalDB["Temporal Database<br/>(PostgreSQL 16)"]
        TemporalUI["Temporal Web UI<br/>(:8080)"]
    end

    UI -->|REST / SWR| Backend
    Agent -->|JSON-RPC / REST| Backend
    External -->|Public API| Backend

    Backend -->|Queries / Migrations| Postgres
    Backend -->|Session / Rate Limits| Redis
    Backend -->|Trigger Workflows| Temporal

    Orchestrator -->|Poll Task Queues| Temporal
    Orchestrator -->|Status Updates| Postgres

    Temporal -->|Store Execution State| TemporalDB
    Temporal -->|Index Workflows| TemporalES
    TemporalUI -->|Inspect Runs| Temporal

Core Monorepo Subsystems

Component	Path	Responsibility
Backend API	apps/backend	NestJS application handling user authentication (JWT/cookies), organization tenancy, role-based access control, Prisma ORM queries, and public developer endpoints.
Frontend UI	apps/frontend	Next.js and React client using Tailwind CSS, SWR for reactive data fetching, and live platform preview components.
Orchestrator	apps/orchestrator	Dedicated NestJS worker daemon that registers workflows and runs Temporal activities for timed publication, video generation, and token refresh.
Social Libraries	libraries/nestjs-libraries/src/integrations/social	Adapter layer housing 38 distinct social provider implementations, each normalizing media uploads, text limits, and OAuth token exchanges.
Agent Integration	libraries/nestjs-libraries/src/agent	Graph-based agent service and MCP server integration supporting Dynamic Client Registration (RFC 7591) for autonomous agents.

---

3. The Temporal Workflow Engine

The defining architectural decision in Postiz is delegating task scheduling to Temporal.io rather than a simple queue like BullMQ or a basic database cron poll.

Scheduling social posts introduces challenging failure modes:

1. Durable Timers: Posts can be scheduled minutes, weeks, or months into the future. Maintaining millions of long-sleeping jobs in Redis memory is inefficient and vulnerable to queue evictions.
2. Deterministic Retries: Social networks regularly fail during execution. Twitter API rate limits, expired Facebook page tokens, and transient YouTube video upload errors require intelligent, stateful exponential backoff.
3. Multi-Step Pipelines: Publishing a video post involves polling video transcoding status, uploading chunks, waiting for provider verification, and then posting caption text.

sequenceDiagram
    autonumber
    actor User as User / MCP Agent
    participant API as NestJS Backend
    participant DB as PostgreSQL 17
    participant Temp as Temporal Engine
    participant Worker as Orchestrator Worker
    participant Social as Social Network (X / LinkedIn)

    User->>API: Submit scheduled post with media
    API->>DB: Save post entity (Draft / Scheduled)
    API->>Temp: Start post.workflow.v1.1.2 (target_date)
    Temp-->>API: Workflow execution started (WorkflowId)
    API-->>User: 201 Created (post queued)

    Note over Temp: Temporal engine sleeps durably until target_date

    Temp->>Worker: Dispatch task to task_queue
    Worker->>DB: Fetch fresh OAuth access tokens
    Worker->>Social: Upload media attachment
    Social-->>Worker: Media upload confirmation
    Worker->>Social: Publish post content

    alt API Error / Rate Limited
        Social-->>Worker: 429 Too Many Requests / 500 Error
        Worker-->>Temp: Activity failed
        Note over Temp: Exponential backoff retry policy triggers
        Temp->>Worker: Re-execute activity after backoff
    else Success
        Social-->>Worker: 200 OK (Post ID: 123456)
        Worker->>DB: Update post status to PUBLISHED
        Worker->>Temp: Activity completed
    end

Temporal solves this by treating the post lifecycle as code that can sleep, wake up on exact timestamps, and retry failed activities without losing intermediate execution state.

---

4. Visual Tour & Interface Workflows

Postiz pairs its backend orchestrator with an intuitive interface designed for managing multi-network publishing calendars.

Multi-Channel Dashboard & Channel Overview

The central dashboard provides visibility into all connected platform channels, recent posts, audience growth metrics, and active queue health.

Each connected profile displays real-time OAuth token status, platform capabilities, and quick access to individual stream queues.

Scheduling Calendar Grid

The scheduling calendar enables visual time-slot mapping across daily, weekly, and monthly horizons.

Users can drag and drop posts between time slots, identify publishing gaps, and coordinate multi-account campaigns across simultaneous dates.

Multi-Platform Post Composer

Drafting content for multiple networks requires handling distinct character limits, hashtag norms, and media aspect ratios.

The composer renders live previews simultaneously across platforms such as X, LinkedIn, Instagram, Threads, and Reddit, catching formatting errors before scheduling.

---

5. Total Cost of Ownership (TCO)

Evaluating Postiz requires separating open-source software license fees ($0) from server compute, database overhead, and external third-party API costs.

TCO Comparison: Commercial SaaS vs. Postiz Cloud vs. Self-Hosted

The following model compares managing 15 social accounts across three team members publishing approximately 200 posts per month.

Dimension	Commercial SaaS (Buffer / Hootsuite)	Postiz Managed Cloud (Team Tier)	Postiz Self-Hosted (Dedicated VPS)
Software License	$90 to $249/mo	$39/mo flat	$0 (AGPL-3.0)
Compute & Memory	Included	Included	$24 to $40/mo (4GB-8GB VPS)
Database & Cache	Included	Included	Included on VPS (Postgres 17 + Redis)
Workflow Engine	Included	Included	Included on VPS (Temporal + ES 7.17)
Platform API Fees	Absorbed by vendor	Absorbed by Postiz Cloud	Direct developer costs (X API: $0-$100/mo)
Team Seats	Restricted or extra ($/seat)	Unlimited	Unlimited
Upgrade Maintenance	Vendor-managed	Vendor-managed	2-4 hours/month engineering time
Total Annual Cost	$1,080 to $2,988/yr	$468/yr	$288 to $1,680/yr
Operational Burden	Low	Low	Medium to High

Understanding the Self-Hosting Math

1. Compute Sizing: The Postiz Docker Compose stack runs eight distinct containers. Elasticsearch and Temporal alone allocate roughly 2GB of RAM on cold boot. Attempting to deploy on a $5 per month 1GB VPS causes immediate Linux OOM (Out Of Memory) container kills. Budget at least 4GB RAM ($20 to $24 per month on Hetzner or DigitalOcean), or 8GB RAM ($40 per month) for sustained production workloads.
2. Social Developer API Costs: On managed cloud platforms, the vendor pays for developer app verification and enterprise API access. When self-hosting, you must register your own developer applications. Platforms like LinkedIn, Facebook, Instagram, and TikTok allow free API tiers for verified apps. However, X (formerly Twitter) charges $100 per month for their Basic API tier (10,000 read and 50,000 write requests). If X is essential to your stack, self-hosting direct API access adds $1,200 per year unless utilizing existing community keys.

---

6. The Bad: What to Know Before Adopting

Postiz is a capable platform, but self-hosting introduces non-trivial operational complexity:

1. Substantial Memory Footprint: Many self-hosters expect lightweight single-binary Node apps. Postiz runs a distributed system: Elasticsearch 7.17, two distinct PostgreSQL instances (one for app data, one for Temporal), Redis, Temporal auto-setup, and the NestJS services. It requires serious server headroom.
2. Developer Application Onboarding Friction: To publish natively to Facebook, Instagram, LinkedIn, or TikTok from a self-hosted instance, you must create developer accounts with each vendor, submit app privacy policies, complete business verification, and configure redirect URIs. This process can take days or weeks for platform approvals.
3. Dangerous Auth Flags: The environment file includes a NOT_SECURED=true flag designed for single-user local development without login screens. If this flag is accidentally left set on a publicly exposed server, any visitor gains unrestricted administrative control over the entire platform.
4. SSRF Risks in Federated Plugins: Postiz supports federated and self-hosted destinations like Mastodon, Lemmy, and WordPress sites. A configuration flag DISABLE_SSRF_PROTECTION exists in the codebase. This must always remain false in production to prevent malicious actors from using the Postiz backend to scan your private internal VPC networks.
5. AGPL-3.0 Copyleft Terms: Postiz is licensed under the GNU Affero General Public License. If you modify Postiz and offer it as a service over a network, you must make your modified source code available under AGPL-3.0. It is not suitable for closed-source SaaS repackaging.

---

7. Quickstart & Deployment

The standard self-hosted deployment uses Docker Compose.

1. Minimal docker-compose.yaml

A production installation starts the core services alongside the Temporal cluster:

services:
  postiz:
    image: ghcr.io/gitroomhq/postiz-app:latest
    container_name: postiz
    restart: always
    environment:
      - MAIN_URL=https://social.example.com
      - FRONTEND_URL=https://social.example.com
      - NEXT_PUBLIC_BACKEND_URL=https://social.example.com/api
      - JWT_SECRET=replace_with_secure_random_string_32_chars
      - DATABASE_URL=postgresql://postiz:postizpassword@postiz-postgres:5432/postiz
      - REDIS_URL=redis://postiz-redis:6379
      - TEMPORAL_ADDRESS=temporal:7233
      - STORAGE_PROVIDER=local
      - UPLOAD_DIRECTORY=/uploads
      - IS_GENERAL=true
    volumes:
      - ./uploads:/uploads
    ports:
      - "5200:5200"
    depends_on:
      - postiz-postgres
      - postiz-redis
      - temporal

  postiz-postgres:
    image: postgres:17-alpine
    container_name: postiz-postgres
    restart: always
    environment:
      - POSTGRES_USER=postiz
      - POSTGRES_PASSWORD=postizpassword
      - POSTGRES_DB=postiz
    volumes:
      - postgres_data:/var/lib/postgresql/data

  postiz-redis:
    image: redis:7.2-alpine
    container_name: postiz-redis
    restart: always
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

(Note: The full Temporal cluster requires temporal, temporal-elasticsearch, temporal-postgresql, and temporal-admin-tools as provided in the official repository docker-compose.yaml).

2. Autonomous Agent Setup (postiz-agent)

For AI coding agents and autonomous workflows, Postiz provides a dedicated CLI tool compatible with OpenClaw and standard MCP environments:

# Install the Postiz agent CLI
pnpm add -g postiz-agent

# Authenticate against your instance
postiz-agent login --url https://social.example.com --key YOUR_API_KEY

# Schedule a post programmatically
postiz-agent schedule \
  --providers "twitter,linkedin" \
  --content "Automated deployment verified via Postiz orchestrator." \
  --time "2026-09-08T18:00:00Z"

---

8. ReframeHub Recommendation

The Deeper Engineering Insight

Postiz demonstrates the difference between ad-hoc job queues and durable workflow orchestration. Most software projects start scheduling timed tasks with simple database polls or Redis job queues. When tasks need to sleep for thirty days, handle multi-step media pipelines, survive process restarts, and apply platform-specific backoff algorithms, basic queues turn into unmaintainable state machines.

By building on Temporal, Postiz offloads timer durability and retry state to an event-sourced engine. The trade-off is infrastructure weight: running Temporal and Elasticsearch requires more operational maturity than running a single web server.

Who Should Use This?

• Development Agencies & Media Teams: Teams managing 10 to 50 social channels who want to escape per-channel SaaS seat taxes and maintain total ownership over scheduled data.
• Autonomous Agent Builders: Engineers building agentic workflows with OpenClaw, Hermes, or custom MCP agents who need programmatic publishing tools with built-in token management.
• Privacy-Sensitive Organizations: Companies operating under strict compliance rules where social drafts and private tokens cannot sit in third-party multi-tenant databases.

Who Should Stay with Managed SaaS?

• Solo Founders on Budget VPS: If your infrastructure budget is $5 per month and you have no experience managing Elasticsearch or Temporal clusters, the operational overhead will outweigh SaaS convenience. Postiz’s own managed cloud ($29 per month) or a basic Buffer plan is more cost-effective.
• Teams Relying Exclusively on Free Twitter Automation: Because self-hosting requires providing your own developer credentials, publishing to X requires paying Twitter’s $100 per month developer fee directly. Managed SaaS platforms absorb that API fee across their customer pool.