Self-Hosting

Deploy SteelEngine on your own infrastructure

Deploy SteelEngine on your own infrastructure with Docker or Kubernetes.

For internal APIs and MCP servers, configure the app and Temporal Worker's deployment policies together. The production Compose file passes EGRESS_ALLOWLIST and ALLOWED_MCP_DOMAINS to both services. See Private Network Configuration for policy setup, separate API hosts, and verification.

Self-hosting SteelEngine requires an Enterprise subscription. The images live in the private ghcr.io/steelengineai registry, and anonymous pulls are rejected. You need registry credentials as well as the license. Contact sales@steelengine.com for pricing, deployment options, and pull access.

Set Up with Cursor

Requirements

ResourceSmallStandardProduction
CPU2 cores4 cores8+ cores
RAM16 GB16 GB32+ GB
Storage20 GB SSD50 GB SSD100+ GB SSD
Docker20.10+20.10+Latest

Small: Development, testing, single user (1-5 users) Standard: Teams (5-50 users), moderate workloads Production: Large teams (50+ users), high availability, heavy workflow execution

Every tier starts at 16 GB. The Compose file reserves 13 GB of container memory before PostgreSQL. That is 8 GB for the app, 4 GB for the Temporal Worker, and 1 GB for realtime. The Helm chart adds 3 GB for PostgreSQL and migrations by default. Memory is the constraining factor rather than CPU. Workflow execution (isolated-vm sandboxing), file processing, and vector operations (pgvector) all live in RAM. Larger tiers add CPU and storage headroom. The optional Laya Decision server adds a 6 GB limit (about 1 vCPU and 4 GB in use), so add that much when you run it.

These figures cover the SteelEngine containers only. The Temporal server runs outside the Compose stack and needs its own capacity. See Temporal.

Quick Start

SteelEngine needs a running Temporal server before the stack will start. Set one up first with the Temporal guide. Then write the .env described in Docker → 1. Configure Environment. Compose refuses to start without TEMPORAL_WORKER_BROKER_SECRET and TEMPORAL_WORKER_APP_URL.

git clone https://github.com/steelengineai/steelengine.git && cd steelengine
# Sign in with the registry credentials from your subscription
docker login ghcr.io
# Write .env first (secrets, public URLs, TEMPORAL_* settings)
docker compose -f docker/selfhost/compose.yml up -d

Open http://localhost:3000/signup and create the first account. Only an empty database accepts a sign-up without an invitation, so that account is the first admin, and everyone else joins by invitation.

Deployment Options

Workflow Checkpoint Upgrades

Releases with checkpoint state V4 support require a manual, once-per-database activation to enable payload deduplication. Normal schema migrations leave the existing write version unchanged. Upgrade every application reader and worker before activation, including older draining workers. See Workflow checkpoint upgrades for the dedicated-installation runbook and rollback limits.

Architecture

ComponentPortDescription
steelengine3000Main application
steelengine-worker3003 (internal)Temporal Worker that runs workflows, schedules, and background jobs. The port serves health checks and Task Queue backlog stats and is not published
realtime3002WebSocket server
db5432PostgreSQL with pgvector
migrations-Database migrations (runs once)
Temporal server7233Not part of the Compose file. You run ghcr.io/steelengineai/temporal-server yourself. See Temporal

The Compose file pulls steelengine, worker, realtime, and migrations from ghcr.io/steelengineai. PostgreSQL comes from pgvector/pgvector:pg17 on Docker Hub. The app and the Temporal Worker share ENCRYPTION_KEY, INTERNAL_API_SECRET, and TEMPORAL_WORKER_BROKER_SECRET. Realtime receives BETTER_AUTH_SECRET and INTERNAL_API_SECRET but never the broker secret.

Common Questions

At minimum you need 2 CPU cores, 16 GB RAM, 20 GB SSD storage, and Docker 20.10 or later. You also need a Temporal server that the containers can reach. The Compose file alone reserves 13 GB of container memory (8 GB app, 4 GB Temporal Worker, 1 GB realtime) before PostgreSQL. Memory is typically the constraining factor due to workflow execution (isolated-vm sandboxing), file processing, and vector operations (pgvector).
SteelEngine uses PostgreSQL 17 with the pgvector extension for vector similarity search. The Docker setup uses the pgvector/pgvector:pg17 image, which comes with the vector extension pre-installed.
Four secrets are required for the standard Temporal deployment: BETTER_AUTH_SECRET (authentication), ENCRYPTION_KEY (data encryption), INTERNAL_API_SECRET (general service-to-service auth), and a separate TEMPORAL_WORKER_BROKER_SECRET used only by web and the Temporal Worker. Generate each independently with openssl rand -hex 32. Set NEXT_PUBLIC_APP_URL, BETTER_AUTH_URL, NEXT_PUBLIC_SOCKET_URL, and TEMPORAL_WORKER_APP_URL to your domain. Add the Temporal connection settings: TEMPORAL_ADDRESS, TEMPORAL_NAMESPACE, TEMPORAL_SERVER_NAME, TEMPORAL_AUTH_ISSUER, TEMPORAL_AUTH_JWKS_URL, and TEMPORAL_BUILD_ID.
The realtime service is a dedicated WebSocket server that runs on port 3002. It handles real-time communication for features like live workflow execution updates. It has a 1 GB memory limit. At startup it checks for DATABASE_URL, a BETTER_AUTH_SECRET that matches the web app, INTERNAL_API_SECRET (both at least 32 characters), and APP_URL or NEXT_PUBLIC_APP_URL. The Compose file passes all of these.
The migrations container runs once at startup (restart: no) and executes bun run db:migrate to apply database schema changes. It depends on the database being healthy before running and must complete successfully before the main application starts.
No. docker/selfhost/compose.yml runs the app, the Temporal Worker, realtime, PostgreSQL, and migrations. The Temporal server is a separate deployment that you operate. SteelEngine publishes ghcr.io/steelengineai/temporal-server, which is Temporal 1.31.2 with SteelEngine token verification built in. The Temporal page covers its configuration and the schema and namespace bootstrap.
Yes. SteelEngine supports Ollama for local model inference. Point OLLAMA_URL at an Ollama server the containers can reach. Use http://host.docker.internal:11434 on macOS and Windows, or your host IP on Linux. Start the stack with the same docker/selfhost/compose.yml.

On this page