Presentator: The Self-Hosted Design Tool Teams Are Secretly Switching To

What if every design review cost you nothing? No per-seat pricing. No storage limits. No vendor lock-in. Just pure, frictionless collaboration between designers, developers, and stakeholders.

Here's the brutal truth most agencies won't admit: they're hemorrhaging thousands annually on design feedback tools that fundamentally disrespect their workflow. Figma's comment system? Buried under layers of UI. InVision? Sold to a private equity firm, future uncertain. Adobe XD? Discontinued entirely. The SaaS graveyard is littered with tools that promised seamless collaboration but delivered subscription fatigue and data hostage situations.

But something fascinating is happening in the developer community. A quiet exodus. Teams are abandoning cloud-locked platforms for something radical: a single executable that transforms any server into a professional design presentation and feedback powerhouse.

Meet Presentator — the open-source design feedback and presentation platform that's redefining how technical teams handle creative collaboration. Built on the rock-solid foundation of PocketBase, engineered in Go for blistering performance, and deployable anywhere from a Raspberry Pi to enterprise infrastructure. This isn't just another tool. It's a declaration of independence from the design SaaS industrial complex.

Ready to understand why senior developers are whispering about this in Discord channels? Let's dissect what makes Presentator genuinely disruptive.

What is Presentator?

Presentator is a free, open-source design feedback and presentation platform created by Gani Georgiev, a developer who clearly understood that design collaboration shouldn't require surrendering your data to Silicon Valley servers or paying escalating subscription fees for features you barely use.

At its architectural core, Presentator leverages PocketBase — the increasingly popular open-source backend in a single file. This isn't accidental brilliance; it's strategic genius. By building atop PocketBase, Presentator inherits instant super-admin dashboards, built-in authentication, file storage management, and a extensible hook system — all without writing thousands of lines of boilerplate infrastructure code.

The project is written in Go, compiled to a single static binary, and distributed with zero dependencies. No Docker complexity unless you want it. No Node.js version conflicts. No npm install nightmares. Just download, execute, collaborate.

Why it's trending now: The convergence of three forces has created perfect conditions for Presentator's rise. First, post-pandemic remote teams demand async design review tools but reject per-seat pricing that punishes growth. Second, privacy-conscious organizations — especially in EU jurisdictions with GDPR complexity — increasingly mandate self-hosted solutions. Third, the Go ecosystem's maturation means single-binary deployments are now genuinely production-viable, not hobbyist experiments.

Presentator occupies a unique position: more focused than generic project management tools, more affordable than dedicated design SaaS platforms, and more developer-friendly than consumer-grade alternatives. It's the infrastructure your design team deserves.

Key Features That Demand Attention

Presentator's feature set reveals thoughtful engineering prioritizing pragmatism over bloat. Here's what separates it from pretenders:

Single-Binary Deployment Architecture The entire application ships as one executable. This isn't marketing fluff — it's a genuine operational advantage. Updates via ./presentator update with automatic pb_data snapshots. Rollback in seconds if something breaks. This deployment simplicity slashes DevOps overhead to near-zero.

Built-in Super-Admin Dashboard (PocketBase) Access at /_/ and you get PocketBase's legendary admin interface. Configure SMTP, OAuth2 providers, S3 storage, and application settings through a clean UI rather than YAML archaeology. First-run super-admin creation means no default credentials lurking in your infrastructure.

Flexible Authentication Ecosystem Native support for Google, Microsoft, Facebook, GitHub, GitLab OAuth2 providers. But critically, Presentator doesn't force social login — traditional email/password flows work seamlessly. The OAuth2 redirect URL structure (/api/oauth2-redirect) follows standard patterns, making reverse proxy configuration predictable.

Configurable File Storage Default local filesystem storage for simplicity, with S3-compatible object storage integration for scale. Whether you're managing hundreds of screens or tens of thousands, storage architecture adapts without application rewrites.

Customizable Legal & Branding Surface --termsUrl and --footerLinks flags let organizations inject their own legal frameworks and navigation without forking the codebase. This matters enormously for enterprise adoption where compliance isn't negotiable.

Extensible Hook System (Go + JavaScript) This is where Presentator transcends "nice tool" territory. The PocketBase foundation enables both Go package imports for compiled extensions and JavaScript hooks for rapid iteration. Comment workflows, notification pipelines, custom validations — all programmable without core modifications.

Automatic TLS via Let's Encrypt Production deployment with presentator serve yourdomain.com handles certificate provisioning automatically. The kind of zero-config security that makes operators weep with joy.

Real-World Use Cases Where Presentator Dominates

Scenario 1: Agency Client Reviews Creative agencies juggle dozens of client projects simultaneously. Presentator's self-hosted nature means each major client can have their own isolated instance, branded appropriately, with data residency guaranteed. No more awkward conversations about where proprietary designs live. The OAuth2 integration means clients authenticate with their existing corporate identity providers — friction eliminated, professionalism elevated.

Scenario 2: Game Development Studios Game studios produce massive volumes of concept art, UI mockups, and level designs requiring iterative feedback from distributed teams. Presentator's configurable upload limits (beyond the default ~7MB) accommodate high-resolution artwork, while the comment system captures contextual feedback directly on visual elements. The Go-based backend handles concurrent review sessions without the latency spikes that plague browser-heavy alternatives.

Scenario 3: Healthcare & Financial Services Compliance Industries with strict data governance requirements often can't use consumer SaaS tools. Presentator self-hosted on private infrastructure, with SMTP integration to internal mail gateways, creates audit-friendly collaboration pipelines. The BSD 3-Clause license permits internal modifications without legal review nightmares.

Scenario 4: Open Source Design Communities Projects like GNOME, KDE, or independent design tool ecosystems need public feedback mechanisms without platform dependency. Presentator's zero-cost model and source availability align perfectly with open source values. Communities can maintain their own instances, contribute improvements upstream, and never worry about acquisition-driven feature deprecation.

Step-by-Step Installation & Setup Guide

Presentator's installation borders on insultingly simple. Here's the complete path from zero to functioning design collaboration platform.

Prerequisites

• Linux, macOS, or Windows server
• Minimum 512MB RAM (1GB+ recommended for production)
• Optional: Domain name with DNS A/AAAA records pointed to your server

Step 1: Download the Binary

Navigate to the GitHub Releases page and download the appropriate binary for your architecture:

# Example for Linux AMD64 — adjust URL for your platform
curl -L -o presentator https://github.com/presentator/presentator/releases/latest/download/presentator_linux_amd64
chmod +x presentator

Step 2: Initial Local Launch

# Start the server — this creates pb_data directory automatically
./presentator serve

By default, Presentator binds to 127.0.0.1:8090. The first launch prompts super-admin creation at http://127.0.0.1:8090/_/.

Step 3: Configure Critical Settings

SMTP Configuration (required for email notifications): Navigate to PocketBase Dashboard > Settings > Mail settings. Enter your provider credentials — Mailjet, MailerSend, Brevo, SendGrid, and AWS SES are all confirmed compatible.

Application URL: Update Settings > Application with your public-facing URL. This ensures generated links in emails route correctly.

S3 Storage (optional but recommended for production): Settings > Files storage — configure your bucket, region, access keys, and endpoint. MinIO, AWS S3, Wasabi, and DigitalOcean Spaces all work through the S3-compatible API.

Step 4: Production Deployment

For Linux servers with public domains, the simplest path:

# Upload your configured pb_data and binary
rsync -avz -e ssh /local/path/to/presentatordir/ root@YOUR_SERVER_IP:/root/pr

# SSH in and start with automatic TLS
ssh root@YOUR_SERVER_IP
/root/pr/presentator serve yourdomain.com

This binds ports 80 and 443, provisions Let's Encrypt certificates automatically, and serves traffic directly.

Step 5: Systemd Service (Production Essential)

Create /lib/systemd/system/presentator.service:

[Unit]
Description = presentator

[Service]
Type           = simple
User           = root
Group          = root
LimitNOFILE    = 4096
Restart        = always
RestartSec     = 5s
StandardOutput = append:/root/pr/errors.log
StandardError  = append:/root/pr/errors.log
ExecStart      = /root/pr/presentator serve yourdomain.com

[Install]
WantedBy = multi-user.target

Enable and start:

systemctl enable presentator.service
systemctl start presentator

Behind a reverse proxy? Consult PocketBase's production documentation for nginx, Caddy, or Apache configurations.

REAL Code Examples from the Repository

Presentator's extensibility shines through concrete implementation patterns. Here are actual code examples from the repository, annotated for clarity.

Example 1: JavaScript Hook for Comment Notifications

The simplest extension path uses JavaScript files in pb_hooks/:

// pb_hooks/main.pb.js
/// <reference path="../pb_data/types.d.ts" />

// This hook fires after ANY comment record creation request
onRecordCreateRequest((e) => {
    // Extract the comment message from the created record
    console.log(e.record.get("message"))
    
    // CRITICAL: e.next() passes control to the next handler
    // Omitting this breaks the request chain entirely
    e.next()
}, "comments");  // "comments" targets only the comments collection

What's happening here: This hook intercepts comment creation, enabling custom notification pipelines. In production, you'd replace console.log with Slack webhooks, email dispatches, or database logging. The /// <reference> directive provides TypeScript intelligence for PocketBase's API surface.

Example 2: Custom Go Extension with Presentator Package

For compiled performance and complex logic, extend via Go:

package main

import (
    "log"

    "github.com/pocketbase/pocketbase/core"
    "github.com/presentator/presentator/v3"
)

func main() {
    // Initialize Presentator application instance
    // This bootstraps all default collections, routes, and middleware
    pr := presentator.New()

    // Bind to comment creation events with type-safe handler
    pr.OnRecordCreateRequest("comments").BindFunc(func(e *core.RecordRequestEvent) error {
        // Extract message field with safe string conversion
        log.Println(e.Record.GetString("message"))
        
        // e.Next() continues to default Presentator handlers
        // Return error here to abort creation (validation, auth checks, etc.)
        return e.Next()
    })

    // Start blocking server — this runs until interrupted
    if err := pr.Start(); err != nil {
        log.Fatal(err)
    }
}

Why this pattern matters: You're not forking Presentator or maintaining a patch set. You're importing it as a library, adding your logic, and running your own binary. The presentator.New() constructor handles all boilerplate — your code focuses purely on business logic.

Example 3: Custom Footer Links via CLI Flags

# Inject multiple footer links with pipe-delimited format
./presentator serve \
  --footerLinks='Privacy|https://example.com/privacy, Contact|https://example.com/contact, Status|https://status.example.com'

This demonstrates Presentator's configuration philosophy: common customizations exposed as flags, eliminating config file templating for simple cases.

Example 4: Terms URL Injection

# Required for GDPR-compliant user registration flows
./presentator serve --termsUrl='https://example.com/legal/terms-of-service'

The --termsUrl flag surfaces your legal document during registration, creating auditable consent trails without code modifications.

Example 5: Update with Backup Control

# Default: creates automatic pb_data snapshot before updating
./presentator update

# Production automation: disable backup for faster CI/CD pipelines
./presentator update --backup=0

The update mechanism exemplifies operational thoughtfulness — safe by default, flexible when needed.

Advanced Usage & Best Practices

Performance Optimization: Presentator's Go backend handles substantial concurrent load, but for high-traffic scenarios, deploy behind a reverse proxy with HTTP/2 and Brotli compression. The single-binary design makes horizontal scaling straightforward — run multiple instances behind a load balancer with shared S3 storage.

Backup Strategy: The pb_data directory contains your entire application state. Implement automated snapshots before updates, and schedule regular off-site backups. SQLite's single-file nature makes this trivial compared to database server orchestration.

Security Hardening: Beyond automatic TLS, restrict PocketBase admin access to VPN or internal networks. The /_/ path is powerful — treat it accordingly. Enable OAuth2 for user-facing authentication to eliminate password management risks.

Hook Development Workflow: Start with JavaScript hooks for rapid prototyping, migrate performance-critical paths to Go. The identical event model makes translation seamless. Version your pb_hooks directory in Git for reproducible deployments.

Storage Planning: Local storage works to ~10GB comfortably. Beyond that, migrate to S3 early — retroactive migration is painful. Monitor the screens collection's file field size limits; adjust before users hit walls.

Comparison with Alternatives

The verdict: Presentator wins where control, cost-predictability, and extensibility matter. Figma and Marvel lead for pure designer experience in unconstrained SaaS environments. InVision's future is questionable post-acquisition. Custom builds only make sense for organizations with dedicated platform teams and unique requirements.

FAQ

Is Presentator truly free for commercial use? Yes. The BSD 3-Clause license permits commercial use, modification, and distribution with minimal attribution requirements. No feature gates, no "open core" premium tier.

Can I migrate from Presentator v2 to v3? Absolutely. Use the dedicated v2tov3migrate tool. The v3 rewrite on PocketBase represents significant architectural improvement — migration is strongly recommended.

How does Presentator handle large design files? Default screen uploads are limited to ~7MB, but this is configurable through the PocketBase admin dashboard. For 4K+ mockups or video prototypes, increase the screens collection's file field limit.

What happens to my data if the project stops being maintained? Because you self-host and the data format is standard SQLite, you retain complete control. The PocketBase foundation means even without active Presentator development, your data remains accessible and exportable.

Can I use Presentator without a public domain? Yes. Local development uses 127.0.0.1:8090. For team access without public DNS, deploy on your internal network with IP-based access or private DNS.

Is there a hosted option if I don't want to self-host? The free hosted service at app.presentator.io provides immediate access without infrastructure management. Ideal for evaluation and small teams.

How does comment threading work compared to Figma? Presentator implements contextual comments pinned to specific screen coordinates. While less visually integrated than Figma's canvas-native system, the focused feedback model often reduces noise in large review sessions.

Conclusion

Presentator represents something increasingly rare in modern tooling: genuine engineering integrity. No venture capital growth pressure. No surveillance capitalism business model. Just a solid, extensible platform that solves real problems for teams who value their autonomy.

The single-binary deployment model, PocketBase-powered admin experience, and dual Go/JavaScript extension paths create a foundation that adapts to your workflow rather than demanding adaptation. Whether you're a solo designer tired of subscription creep, an agency protecting client data, or an enterprise navigating compliance complexity, Presentator offers a credible, sustainable path forward.

The design tool landscape will continue consolidating and commoditizing. Tools you rely on today may pivot, price-hike, or disappear entirely. Presentator's open-source foundation and self-hosted architecture insulate you from that volatility.

Your next step is simple: Visit github.com/presentator/presentator, download the latest release, and have a functioning design feedback platform running in under ten minutes. The hosted version at app.presentator.io offers zero-commitment exploration. Either way, you'll quickly understand why technical teams are quietly making the switch.

Own your design workflow. Start with Presentator today.