Deploy and Host Outpost on Railway

Outpost is an open source event delivery service for teams building API platforms. It lets you deliver outbound webhooks and Event Destinations to user-owned endpoints and queues with retries, signatures, observability, topics, and fanout. Deliver to webhooks, Hookdeck Event Gateway, RabbitMQ, AWS SQS, AWS Kinesis, Azure Service Bus, and more.

Outpost is built and maintained by Hookdeck.

About Hosting Outpost

This template runs Outpost as a single process on Railway. The app exposes an HTTP API and includes internal workers that handle delivery, publishing, and logging. PostgreSQL is used for log storage and Redis for coordination and caching. The template provisions what is needed and wires everything together for you. You can scale vertically as needed within Railway's service limits. Outpost receives publish requests from your platform or a queue and delivers events to destinations your customers control, with observability and operational safeguards built in.

Required Configuration

As part of the deployment process, configure your TOPICS environment variable to the topics supported for destination subscriptions, publishing, and routing of events. For example, TOPICS=user.created,user.updated,user.deleted. TOPICS is strictly optional, but recommended so it's required for this template.

Get Started

Once deployed, you'll need:

• The public URL of your Outpost instance so you can integrate with the Outpost API ({RAILWAY_URL}/api/v1) -
• The generated API_KEY environment variable value to authenticate requests.

Read the getting started with Outpost and Railway guide for more information.

Common Use Cases

• Add reliable outbound webhooks with automatic retries and signatures
• Offer delivery of events directly to queues and buses like Hookdeck Event Gateway, SQS, Kinesis, RabbitMQ, and Azure Service Bus
• Provide a tenant user portal for self-serve destination management and replays
• Centralize delivery logs, metrics, and traces for debugging and incident response

When to Use This Template

This single-process deployment is ideal for:

• Development and testing environments
• Proof-of-concept projects
• Small to medium-scale production workloads (see Performance and Scaling section)
• Teams getting started with Outpost

For high-traffic production environments requiring optimal performance and scalability, consider a multi-service deployment that separates API, delivery, and logging services. If you need a multi-service Railway template, please raise an issue to request one.

Outpost Features

• Multi-tenant support - create multiple tenants in a single deployment
• Event Destinations - webhooks, Hookdeck Event Gateway, RabbitMQ, AWS SQS, AWS Kinesis, Azure Service Bus, with Amazon EventBridge, GCP Pub/Sub, Kafka and S3 coming soon
• Topics and subscriptions - segment events by type and fan out to multiple endpoints
• Publishing - via the HTTP publish API or by reading from a configured queue
• Delivery and retries - at least once delivery with automatic and manual retries
• Alerts - consecutive failure alerts and auto-disable to protect downstreams
• Tenant user portal - optional portal for destination config, replays, and inspection
• OpenTelemetry - standardized traces, metrics, and logs
• Logging - configurable verbosity for API and workers
• Webhook best practices - idempotency, timestamp and signature headers, and key rotation

Dependencies for Outpost Hosting

• PostgreSQL for log storage
• Redis for coordination and caching
• RabbitMQ for delivery and log queuing

Deployment Dependencies

• Railway account (free tier supports up to 4 services)

References

• Outpost docs: https://outpost.hookdeck.com/docs
• GitHub repository: https://github.com/hookdeck/outpost
• GitHub issues: https://github.com/hookdeck/outpost/issues

Why Deploy Outpost on Railway?

Railway is a singular platform to deploy your infrastructure stack. Railway will host your infrastructure so you don't have to deal with configuration, while allowing you to vertically and horizontally scale it.

By deploying Outpost on Railway, you are one step closer to supporting a complete full-stack application with minimal burden. Host your servers, databases, AI agents, and more on Railway.

Performance and Scaling

Benchmark

With approximately $100/month in Railway resources, Outpost can comfortably handle 200 events/second under the following test conditions:

• 1 second average delivery latency
• 7KB event payload size
• Initial delivery attempts (minimal database interaction)

Resource allocation for this benchmark:

• PostgreSQL: 1 vCPU, 1GB RAM (~$30/month)
• RabbitMQ: 0.5 vCPU, 1GB RAM (~$20/month)
• Redis: 0.5 vCPU, 1GB RAM (~$20/month)
• Outpost Compute: 1 node, 1 vCPU, 1GB RAM (~$30/month, 250 concurrent deliveries)

These figures assume successful initial deliveries with minimal retries. Event volumes requiring significant retry processing may require additional resources. Configure your Railway services according to your specific throughput and reliability requirements.

Scaling Configuration

The primary configuration for scaling Outpost throughput is DELIVERY_MAX_CONCURRENCY, which controls how many events can be delivered in parallel. Higher concurrency increases throughput but may increase database connections during retry scenarios (Outpost only queries the database to fetch retry payloads, not for initial delivery attempts).

Scaling strategies:

1. Vertical scaling - Increase DELIVERY_MAX_CONCURRENCY and allocate more CPU/memory to handle additional concurrent deliveries on a single node
2. Horizontal scaling - Add more Outpost nodes and distribute the load across multiple instances

Outpost is designed for horizontal scaling. You can combine both approaches by running multiple nodes each with higher concurrency settings.

Important: This template configures a single node running all Outpost services (API, delivery, and logging). For high availability and optimal throughput in production, consider deploying separate nodes for each service type with independent scaling configurations.