Environment Variables

Configuration reference for SteelEngine

Required

The app needs all of these. The Temporal Worker and the realtime server read the same DATABASE_URL, ENCRYPTION_KEY, and INTERNAL_API_SECRET. Realtime also needs BETTER_AUTH_SECRET.

VariableDescription
DATABASE_URLPostgreSQL connection string. docker/selfhost/compose.yml assembles it from POSTGRES_USER, POSTGRES_PASSWORD, and POSTGRES_DB
BETTER_AUTH_SECRETAuth secret (32 hex chars): openssl rand -hex 32. Must be identical on the app and realtime
BETTER_AUTH_URLYour app URL
ENCRYPTION_KEYEncryption key (32 hex chars): openssl rand -hex 32
INTERNAL_API_SECRETInternal API secret (32 hex chars): openssl rand -hex 32
NEXT_PUBLIC_APP_URLPublic app URL. The server reads it at runtime to set the browser origin allowed credentialed CORS on /api/* and the app origin in the Content-Security-Policy

The production Compose file layers these on top:

VariableDescription
TEMPORAL_WORKER_BROKER_SECRETSeparate 32+ byte secret used only between web and the Temporal Worker credential broker. Compose exits without it
TEMPORAL_WORKER_APP_URLHTTPS URL of the app as seen from the Worker. Compose passes it to the Worker as APP_URL and exits without it
NEXT_PUBLIC_SOCKET_URLWebSocket URL (default: http://localhost:3002)
TEMPORAL_ADDRESS, TEMPORAL_NAMESPACE, TEMPORAL_SERVER_NAME, TEMPORAL_AUTH_ISSUER, TEMPORAL_AUTH_JWKS_URL, TEMPORAL_BUILD_IDNo default. The Worker fails at startup when any of them is empty. See Temporal

Separate API and site hosts

Most deployments serve everything from NEXT_PUBLIC_APP_URL and leave these unset. Set them only when outside callers or marketing pages use a different host from the app.

VariableDescription
PUBLIC_API_URLStable URL that outside systems call (default: the app URL). It is the Temporal token issuer and JWKS host, the MCP OAuth issuer and resource URLs, the webhook and Slack event URLs registered with providers, and the default URL in exported workflow clients. Changing it later breaks running workflows, connected MCP clients, and registered webhooks
NEXT_PUBLIC_API_URLBrowser copy of PUBLIC_API_URL, used for the MCP and webhook URLs shown in the UI. Set it to the same value
NEXT_PUBLIC_SITE_URLMarketing site URL (default: the app URL). Used for the privacy and terms links in emails, robots.txt, sitemap.xml, llms.txt, and canonical links on public pages

Changing the public application URL

Set NEXT_PUBLIC_APP_URL, BETTER_AUTH_URL, and the Worker's public APP_URL consistently. Organization URL previews and generated form links use the configured application host; form links preserve its scheme and port. Keep the email sender domain configured separately from the application hostname.

Keep TEMPORAL_AUTH_ISSUER stable across the app, Workers and Temporal server when changing the public URL. Keep JWKS retrieval, MCP resources, and provider webhook destinations on PUBLIC_API_URL. Set NEXT_PUBLIC_API_URL to that same stable API URL, and NEXT_PUBLIC_SITE_URL to the marketing host. Update login and integration OAuth callback registrations for the application host, retaining old callbacks during the transition where supported.

The hosted production migration activates only when the configured app URL is exactly https://app.steelengine.com. GET/HEAD requests reaching the application on steelengine.com or www.steelengine.com for authentication, invitations, app entry pages and valid non-reserved organization paths temporarily redirect to the app host before cookies are set. The new host's / uses /app; the apex keeps its marketing pages and canonical URLs. New password-reset links requested on those old production hosts also use the app host. API callbacks, OAuth consent, public embeds, assets and non-GET/HEAD requests retain their handlers. This policy does not activate for self-hosted or development app URLs. Old-host traffic must continue reaching the application, and any proxy in front of it must preserve the original Host header; X-Forwarded-Host is not used.

MCP OAuth uses the stable public API origin as its issuer and resource audience. Moving only the application host does not change existing MCP resource URLs or require an issuer migration; continue using the API host for MCP connections. App-host resource aliases are rejected. Keep Temporal's separate issuer stable. Browser sessions and local storage do not transfer between unrelated origins, so users should expect to sign in again.

Temporal

Every deployment runs its own Temporal server. See Temporal. The app and the Worker share the connection settings:

VariableDescription
TEMPORAL_ADDRESSgRPC frontend as host:port, no scheme
TEMPORAL_NAMESPACENamespace created during bootstrap (app default: steelengine-local)
TEMPORAL_TLS_ENABLEDtrue in production. Compose and Helm default to true
TEMPORAL_SERVER_NAMETLS name on the server certificate. Requires TEMPORAL_TLS_ENABLED
TEMPORAL_TLS_CA_PEM, TEMPORAL_TLS_CA_PATHPrivate CA for the frontend certificate, inline (PEM or base64 PEM) or as a file path
TEMPORAL_AUTH_ISSUERIssuer written into every token. The app defaults to PUBLIC_API_URL, then BETTER_AUTH_URL. The Worker has no default, so set it on both
TEMPORAL_AUTH_AUDIENCETransport audience (default: steelengine-temporal-rpc)
TEMPORAL_IDENTITYSDK identity of this process. The Worker's value must equal its token subject
TEMPORAL_ALLOW_INSECURE_AUTHTokens over plaintext. Loopback development only. Rejected together with TEMPORAL_TLS_ENABLED=true

App only:

VariableDescription
TEMPORAL_WORKER_IDENTITYExact Worker subject the credential broker will issue tokens for (default in Compose: steelengine-temporal-worker)
TEMPORAL_WORKER_BROKER_SECRETBroker proof secret. The broker returns 503 until this and TEMPORAL_WORKER_IDENTITY are set
TEMPORAL_EXECUTION_MODEper_block, the only supported value
TEMPORAL_AUTH_PRIVATE_KEY_FILEDevelopment-only local signing key. Production signs with the Better Auth JWKS key pair

Worker only:

VariableDescription
APP_URLApp URL for the credential broker and internal callbacks. Must be HTTPS in production
TEMPORAL_WORKER_CREDENTIAL_BROKER_ENABLEDtrue to fetch short-lived tokens from the app (Compose sets it). Mutually exclusive with TEMPORAL_API_KEY and TEMPORAL_API_KEY_FILE
TEMPORAL_API_KEY, TEMPORAL_API_KEY_FILEA worker token you issued, inline or as a file. The Worker re-reads the file every TEMPORAL_API_KEY_REFRESH_INTERVAL_MS (default 30,000). Set one, not both
TEMPORAL_AUTH_JWKS_URL, TEMPORAL_AUTH_JWKS_FILEWhere the Worker verifies tokens. Set exactly one. Production requires the HTTPS URL
TEMPORAL_REQUIRE_EXECUTION_IDENTITYVerify the signed execution identity on every Activity. Defaults to true in production and cannot be turned off there
TEMPORAL_DEPLOYMENT_NAMEWorker deployment name (default: steelengine-temporal-worker)
TEMPORAL_BUILD_IDBuild identifier for Worker versioning. Change it with every new Worker image
TEMPORAL_WORKER_PORTHealth server port (default: 3003)
TEMPORAL_ACTIVITY_MEMORY_TARGETOptional fraction greater than 0 and less than 1, for example 0.85. At or above this fraction of the container's memory limit, the Worker pauses new Activity slot reservations above a minimum of one per queue. Already-reserved slots and running Activities are retained. When unset or no container memory limit can be read, only the per-queue concurrency counts apply
TEMPORAL_MAX_ACTIVITY_TASK_POLLERSMost Activity Task polls each queue Worker holds open at once, for every queue in the process. When unset, the workflows queue holds up to 30 and the other queues up to 10, or fewer when the queue has fewer Activity slots. Every poll counts toward the Temporal server's per-namespace poll limit, so lower it before adding Worker replicas. See Temporal → Scaling Workers
TEMPORAL_MAX_WORKFLOW_TASK_POLLERSMost Workflow Task polls each queue Worker holds open at once, sticky and normal together, for every queue in the process. At least 2. When unset, up to 10, or fewer when the queue has fewer Workflow Task slots
TEMPORAL_POLLER_AUTOSCALINGtrue to let each queue Worker scale its Activity and Workflow Task polls from the server's feedback, from 1 (2 for Workflow Tasks) up to the maximums above, instead of always holding the maximum open (default: false). Idle queues then hold fewer polls. With a maximum unset, the limit is the default maximum above
TEMPORAL_SHUTDOWN_GRACE_TIME_MS, TEMPORAL_SHUTDOWN_FORCE_TIME_MSDrain window on shutdown (defaults 30,000 and grace + 30,000). Once shutdown starts, the Worker lets blocks that are already running finish but starts no new ones, so each run continues from its last finished block on another Worker
TEMPORAL_PARALLEL_RECORD_CHAINStrue to let a parallel branch run its following blocks in the same Activity, up to the next Wait, approval, Response, child workflow call, loop or nested parallel, instead of one Workflow round per block (default: false). Each block is still claimed and recorded before the branch's results are merged, so retries and effect fencing are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker merging the branch would miss the blocks it ran and run them again
TEMPORAL_PARALLEL_WINDOW_CHAINStrue to let a child workflow called inside a Parallel Window run its following blocks in the same Activity, up to its return, a nested child call, a loop, a Parallel or a failed block, instead of one window round per block (default: false). Each block is still claimed and recorded before the window merges it, and the window's concurrency limit, results, logs and order are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker merging the item would miss the blocks it ran and run them again
TEMPORAL_PARALLEL_WINDOW_INLINE_CHAINStrue, together with TEMPORAL_PARALLEL_WINDOW_CHAINS, to also let a Parallel Window item run its own following blocks in the same Activity, not only a child workflow's, instead of one window round per block (default: false; it has no effect while TEMPORAL_PARALLEL_WINDOW_CHAINS is off). A run stops at the end of the item, a loop iteration's start or end (unless TEMPORAL_PARALLEL_WINDOW_CHAIN_LOOP_CONTROL is on), a child workflow call, an excluded block such as Wait or Response, or a failed block. Each block is still claimed and recorded before the window merges it, and the window's concurrency limit, results, logs and order are unchanged. Enable it only after every Worker runs a release that folds inline chains: an older Worker merging the item would miss the blocks it ran and run them again
TEMPORAL_PARALLEL_WINDOW_CHAIN_LOOP_CONTROLtrue, together with TEMPORAL_PARALLEL_WINDOW_CHAINS, to let a Parallel Window item's run of blocks continue through the loops inside the item (a loop's start, each next iteration and its end) instead of stopping at every one and waiting for the window's next round (default: false; it has no effect while TEMPORAL_PARALLEL_WINDOW_CHAINS is off, and loops directly in the item also need TEMPORAL_PARALLEL_WINDOW_INLINE_CHAINS). Each loop decision, including a While or Do While condition, is evaluated once and recorded; merging the item reuses the recorded decision and never evaluates the condition again. A run still stops after 64 blocks, at a Wait, approval, Parallel, document generation or failed block, at a child workflow call or return, at the end of the item, and on a retried attempt. Results, logs, per-item order, the concurrency limit and exactly-once handling of external calls are unchanged. Every Worker of this release merges recorded loop decisions whatever this setting says, so roll out in steps: deploy the release to every Worker with the setting off, wait until no run still holds loop decisions recorded by an older release (or none were ever recorded), confirm every Worker runs this release, and only then turn it on. An older Worker merging the item could not use the recorded decisions: a release without loop control would run the next iteration's blocks again, and the first release with it would fail the run
TEMPORAL_STREAK_INTO_CHILD_WORKFLOWStrue to let a loop inside a child workflow (a Workflow block's called workflow) run its next iteration in the same Activity, instead of returning to the Workflow once per iteration (default: false). The same rules as for loops in the calling workflow apply: the loop and every Workflow block that leads to it must be outside any Parallel or Parallel Window, and the Activity still stops at a Wait, approval, parallel, document generation block, the block after a single-attempt block, after 64 blocks, and on a retried attempt. Every block still commits its own checkpoint, so outputs, logs, order and recovery are unchanged, and Workers with and without the setting can run side by side
TEMPORAL_PARALLEL_WINDOW_CHILD_SCOPEStrue to schedule a Parallel Window inside a child workflow (a Workflow block that is not itself inside a Parallel Window) the same way as a window in the calling workflow: items are admitted up to the window's concurrency limit, a finished item's slot is refilled at once, and TEMPORAL_PARALLEL_WINDOW_CHAINS applies. Without it such a window runs in lockstep rounds, where every round waits for its slowest item (default: false). It applies to windows whose items settle on error and whose body calls no other workflow; other child windows keep the round-based schedule. Results, logs and per-item order are unchanged. Enable it only after every Worker runs a release that includes it: an older Worker cannot advance a window inside a child workflow
TEMPORAL_PARALLEL_WINDOW_ITEM_STATEHow a Worker folds each Parallel Window item's recorded blocks and advances its loops (default: off). off replays them on the whole window state. on replays them on that item's own share of the run state (its blocks, loops and inputs, without the other items') and merges the item's changes back into the window, so window advancement costs the size of one item rather than of every item in flight, and a window with large items or higher concurrency advances faster. shadow does both, keeps the whole-state result and logs the first difference as an error; use it to check on against live runs, at more cost than either. shadow-strict fails the run on a difference instead, and is meant for tests. true, 1 and yes mean on; false, 0, no or an empty value mean off; any other value stops the Worker at startup. Results, logs, per-item order and checkpoints are the same in every mode, every block runs on the same input, and Workers in different modes can advance the same run, so the setting can be changed at any time. Checkpoints written by the version 1 format always use off

Docker → Temporal Worker lists the per-queue concurrency variables. Task Queue names are fixed and cannot be renamed. Isolate environments with TEMPORAL_NAMESPACE.

Scheduled Assistant Configuration

Scheduled Sub Agents run model and tool calls inside the Temporal Worker. Configure the model-provider environment keys you use on that service as well as on the app. Stored BYOK keys and integration credentials require the same database and encryption settings; file tools require matching storage settings. The task saves model and reasoning choices, not a copy of the credential.

The Worker needs APP_URL, INTERNAL_API_SECRET, and TEMPORAL_WORKER_BROKER_SECRET when assistant tools request scoped credentials to start Temporal workflows. This requirement also applies when TEMPORAL_API_KEY_FILE or TEMPORAL_API_KEY supplies the Worker's polling token. The assistant credential broker does not issue worker or operator tokens. Keep Temporal signing private keys on the app.

See Scheduled Sub Agents for Activity timeouts, retry behavior, and the remaining app dependencies.

Apprise Order-Creation CLI

These settings apply to the source-checkout Apprise CLI. Order creation is not a workflow operation.

VariableDescription
APPRISE_APPROVAL_SECRETSeparate HMAC signing secret of at least 32 characters for CLI approval tokens. Required to mint or verify an approval. Keep separate from application authentication secrets
APPRISE_APPROVAL_NONCE_DIRAbsolute path to shared persistent nonce storage, required for CLI commits. All processes and hosts using the same approval secret must share this directory on a filesystem supporting atomic exclusive creation. No default or in-memory fallback

AI Providers

VariableProvider
OPENAI_API_KEYOpenAI
ANTHROPIC_API_KEY_1Anthropic Claude
GEMINI_API_KEY_1Google Gemini
XAI_API_KEY_1xAI Grok
MISTRAL_API_KEYMistral
FIREWORKS_API_KEYFireworks AI
OPENROUTER_API_KEYOpenRouter. Unset hides OpenRouter models from the picker
OLLAMA_URLOllama (default: http://localhost:11434)

For load balancing, add multiple keys with _1, _2, _3 suffixes (e.g., OPENAI_API_KEY_1, OPENAI_API_KEY_2). Works with OpenAI, Anthropic, Gemini, and xAI.

In Docker, use OLLAMA_URL=http://host.docker.internal:11434 for host-machine Ollama.

Azure OpenAI

VariableDescription
AZURE_OPENAI_API_KEYAzure OpenAI API key
AZURE_OPENAI_ENDPOINTAzure OpenAI endpoint URL
AZURE_OPENAI_API_VERSIONAPI version (e.g., 2024-02-15-preview)
AZURE_ANTHROPIC_API_KEY, AZURE_ANTHROPIC_ENDPOINT, AZURE_ANTHROPIC_API_VERSIONAnthropic models through Azure AI Foundry
NEXT_PUBLIC_AZURE_CONFIGUREDtrue hides the Azure endpoint, key, and version fields in the Agent block once they are set server-side

SteelEngine calls Azure OpenAI with the model ID minus its azure/ prefix as the deployment name, so each deployment must be named exactly like the catalog model (for example, deploy gpt-6-sol for azure/gpt-6-sol). The default Azure OpenAI model is azure/gpt-6-sol; gpt-6-astra and gpt-6-luna are also available.

Once AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY are set, GPT-6 Sol, Luna and Astra (Azure) also appear in the Chat model picker.

Google Vertex AI and AWS Bedrock

VariableDescription
VERTEX_PROJECTGoogle Cloud project ID for Vertex AI
VERTEX_LOCATIONVertex AI region (default: us-central1). The Gemini 4 models are served only from global, us and eu (Gemini 4 Argon also from europe-west2 and asia-southeast1). With no location set, or a us-* region such as the default, they run in the us multi-region; any other location that does not serve the model is refused with an error naming the ones that do
NEXT_PUBLIC_BEDROCK_DEFAULT_CREDENTIALStrue hides the Bedrock access-key fields when the deployment uses the AWS default credential chain (instance profile, task role, IRSA)

vLLM (Self-Hosted)

VariableDescription
VLLM_BASE_URLvLLM server URL without the /v1 suffix (e.g., http://localhost:8000). SteelEngine appends it
VLLM_API_KEYOptional bearer token for vLLM

Laya Decision Server

The Laya Decision block calls a Laya decision server (laya-serve) that you deploy yourself: docker/selfhost/compose.laya.yml for Docker, or laya.enabled in the Helm chart. Set both variables on the app and the Temporal Worker; Laya blocks run in the Worker during workflow runs. Without LAYA_URL the block is hidden from the toolbar, search, and Mothership, Laya does not appear in the model controls, and existing Laya blocks fail with Laya is not available in this environment.

VariableDescription
LAYA_URLBase URL of the Laya server, without /v1/systemone (e.g., http://laya:8000)
LAYA_API_KEYBearer key; the same value the Laya server runs with
LAYA_CAPACITY_URLOptional. Capacity endpoint of an autoscaled Laya deployment (its /_capacity URL). When Laya answers busy or has no healthy host yet, the app or Worker asks it for more hosts (at most once a minute per process) while the block retries
LAYA_CAPACITY_TOKENBearer token for LAYA_CAPACITY_URL

Model and Integration Restrictions

VariableDescription
BLACKLISTED_PROVIDERSComma-separated provider IDs to hide (e.g., openai,anthropic)
BLACKLISTED_MODELSComma-separated model names or prefixes to hide (e.g., gpt-4,claude-*)
ALLOWED_INTEGRATIONSComma-separated block types users may add (e.g., slack,github,agent). Empty allows all
ALLOWED_MCP_DOMAINSComma-separated hostnames workspaces may add as MCP servers. Empty permits public destinations and explicit localhost/loopback URLs. Configured hosts may resolve to private addresses, but metadata and other absolute-deny addresses remain blocked. Other hosts fail with is not allowed by the server's ALLOWED_MCP_DOMAINS policy
ELEVENLABS_API_KEYEnables voice input (speech-to-text) in Chat

The Chat model picker lists models whose provider has a server key or a workspace key, excluding blocked providers and models. When claude-opus-5 is not available, Chat defaults to the first model in the picker; on an Azure-only deployment that is azure/gpt-6-sol. A saved model that loses its provider key or is blocked resolves to that default in Chat, scheduled Sub Agents, and SQL Console AI generation. Reasoning-effort, provider, and organization access checks still apply. An empty roster requires provider configuration before these features can run.

MCP HTTP connections validate and pin every resolved address before connecting, including reconnects. A hostname resolving to loopback is rejected unless the URL explicitly uses localhost or a loopback IP. Redirects are rejected; configure the final MCP endpoint URL. This policy is separate from EGRESS_ALLOWLIST. Set MCP policy on the app and Temporal Worker when both execute MCP tools.

OAuth Providers

Each integration that connects with OAuth reads a <PROVIDER>_CLIENT_ID and <PROVIDER>_CLIENT_SECRET pair. Register an OAuth app in the provider's console. Use the redirect URI <NEXT_PUBLIC_APP_URL>/api/auth/oauth2/callback/<providerId>. Without the pair, the connect button renders but the flow fails with client_id=undefined. Among OAuth providers, only Google can sign in to SteelEngine; email/password and SSO sign-in are unaffected. Every other provider here, GitHub included, only connects an integration to an account that is already signed in, and cannot start a sign-in through either /sign-in/social or the OAuth callback.

VariableDescription
GOOGLE_CLIENT_IDGoogle OAuth client ID (Calendar, Gmail, Drive, Sheets, Docs, Tasks, Contacts share one app)
GOOGLE_CLIENT_SECRETGoogle OAuth client secret
GITHUB_CLIENT_IDGitHub OAuth client ID for the GitHub integration. GitHub is not a sign-in method
GITHUB_CLIENT_SECRETGitHub OAuth client secret
MICROSOFT_CLIENT_ID, MICROSOFT_CLIENT_SECRETOutlook, Excel, Teams, and SharePoint share one app
ATLASSIAN_CLIENT_ID, ATLASSIAN_CLIENT_SECRETJira and Confluence share one app. JIRA_* and CONFLUENCE_* override per product
DISABLE_GOOGLE_AUTHtrue turns off Google sign-in even when its credentials are set. Google integrations keep working

The same pattern applies to SLACK, NOTION, MONDAY, LINEAR, ASANA, AIRTABLE, HUBSPOT, SALESFORCE, PIPEDRIVE, ATTIO, WEALTHBOX, DROPBOX, BOX, DOCUSIGN, WEBFLOW, WORDPRESS, LINKEDIN, X, REDDIT, SHOPIFY, SPOTIFY, ZOOM, SUPABASE, and DISCORD. CALCOM_CLIENT_ID, TRELLO_API_KEY, and APOLLO_API_KEY are single keys with no secret. apps/web/.env.example groups them by category.

Slack Events

These variables configure the deployment-wide hosted Slack app. Custom Slack apps store their configuration in Settings → Integrations → Custom apps instead; see Custom Apps.

VariableDescription
SLACK_SIGNING_SECRETSigning secret for verifying hosted Slack events. No default
SLACK_BOT_EVENTSComma-separated supported bot events enabled in the hosted app's manifest. The Secrets Manager seed script defaults missing values to the seven events below; unset or empty values disable hosted subscriptions. Does not update Slack subscriptions
SLACK_USER_EVENTSRetained configuration key with no effect. Managed workflow triggers accept bot events only

Set the hosted app's Events API request URL to {{API_URL}}/api/integrations/slack/events. The endpoint returns 404 until SLACK_SIGNING_SECRET is set. The hosted app ID is read from the signature-verified event payload; no separate App ID setting is required. Declare only events enabled in the hosted manifest. Bot installation, channel permissions, and workflow deployment are still required before events can start workflows.

The seed script's default event list is:

app_mention,message.channels,message.groups,message.im,message.mpim,reaction_added,reaction_removed

Enable these events under Event Subscriptions → Subscribe to Bot Events. Their bot permissions include app_mentions:read, chat:write, files:read, reactions:read, channels:history, groups:history, im:history, and mpim:history. Channel discovery also needs channels:read, groups:read, im:read, and mpim:read. Reconnect existing installations to authorize newly added scopes. The seed script preserves existing values, including an explicitly empty event list, and does not change settings in Slack.

For local Slack setup through ngrok or another HTTPS tunnel, see Local Development with a Tunnel.

Source Control

These server-side variables configure the deployment-wide GitHub App used by Workspace Source Control. They are separate from the personal GitHub OAuth variables above.

VariableDescription
GITHUB_APP_IDSource Control GitHub App identifier
GITHUB_APP_CLIENT_IDGitHub App OAuth client ID used to browse repositories during setup
GITHUB_APP_CLIENT_SECRETGitHub App OAuth client secret; separate from workflow-action OAuth credentials
GITHUB_APP_PRIVATE_KEYGitHub App PEM private key; escaped \n newlines are supported
GITHUB_APP_WEBHOOK_SECRETGitHub webhook signing secret (minimum 16 characters)

Hosted customers do not set these variables. SteelEngine manages the platform GitHub App; organization admins only install it and choose repository access.

Self-Hosted Promotion

These server-side settings enable self-hosted organization Git releases and the restricted signed-file workflow promotion API/CLI when the remaining promotion configuration is provisioned. They do not enable Kubernetes blue/green cutover. See Organization Releases for availability and Kubernetes Setup for the Helm overlay.

VariableDescription
PROMOTION_ENABLEDDefaults to false. Set true only for a configured self-hosted installation; hosted detection always rejects promotion
PROMOTION_DEPLOYMENT_IDRequired when enabled. Persistent, unique installation UUID; web and both worker roles must agree
PROMOTION_ENVIRONMENT_KEYRequired when enabled. Lowercase environment key such as dev or prod; starts with a letter and contains only letters, digits, or hyphens, up to 63 characters

Configure compatible promotion workers, organization policy, independently provisioned trust, target-local assignments, and the authenticated promotion-notification scheduler before enrollment. The flag does not grant access. Disabling it does not remove an enrolled target's managed-write guards.

Workflow Egress Allowlist

By default, workflow HTTP calls (the API block and fetch inside function blocks) cannot reach private or reserved addresses, and hostnames that resolve to them are rejected the same way. On a self-hosted deployment this means workflows cannot call systems on your own network. EGRESS_ALLOWLIST opens specific destinations without changing the default for anything else.

VariableDescription
EGRESS_ALLOWLISTComma-separated destinations workflows may reach on private networks. Empty by default. Set it on every service that executes workflows: the app and the Temporal Worker.

Each entry is scheme://host:port, optionally followed by =CIDR:

EGRESS_ALLOWLIST="https://erp.corp.internal:8443=10.0.42.0/24,http://legacy-tickets.corp:8080"
  • Exact host. No wildcards and no paths. erp.corp.internal does not cover api.erp.corp.internal.
  • Port required. An entry authorises one port. A URL with no port matches on the scheme default (443 or 80).
  • Scheme is explicit. An http:// entry allows plaintext to that destination only. Use https:// wherever the service supports it.
  • CIDR pin, recommended. When present, the address the host resolves to must fall inside it. This is what stops a DNS change for an allowlisted name from redirecting workflow traffic somewhere else.

An entry can never:

  • reach instance metadata (169.254.0.0/16, fe80::/10, fd00:ec2::254), loopback, unspecified, multicast, or broadcast addresses, even when DNS for the allowlisted name points there
  • open a blocked port (22, 23, 25, 3306, 5432, 6379, 27017, 9200) through an HTTP entry
  • relax anything for a destination that is not listed

A malformed value stops the app and the Worker at startup with a message naming the bad entry, so a typo cannot widen the list or silently disable it.

Every request an entry permits is logged by the EgressAudit logger with the workflow id, workspace id, host, port, resolved IP, and the matching entry. Watch that log after enabling an entry. A destination you did not expect is the signal that something is wrong.

Workflow code is written by workspace users. Every destination in this list is reachable from every workflow on the deployment, including function blocks run from the editor. On a multi-tenant deployment, leave it empty unless a destination is meant to be shared with all tenants.

Private PostgreSQL and MSSQL databases

On self-hosted deployments, the PostgreSQL and MSSQL blocks also accept operator-configured entries in the same variable. Use postgres:// or mssql://, an exact hostname, an explicit port, and a required CIDR pin:

EGRESS_ALLOWLIST="https://erp.corp.internal:8443=10.0.42.0/24,postgres://warehouse.corp:5432=10.0.50.0/24,mssql://sql.corp:1433=10.0.60.0/24"
  • Database entries apply only to the named database provider. They do not permit HTTP requests, and HTTP entries do not permit database connections. The HTTP blocked-port list still applies to HTTP entries; a PostgreSQL entry can explicitly permit port 5432.
  • Every resolved address must be covered by a CIDR for the same scheme, host, and port. Add separate entries for IPv4 and IPv6 when needed. Mixed public/private DNS answers are rejected, as are metadata, loopback, and other reserved addresses, regardless of the pins.
  • Every database socket uses the validated addresses, retaining the original hostname for TLS. Existing TLS settings continue to apply. MSSQL private redirects require an entry for the routed host and port, including redirects that change only the port.
  • Database exceptions are ignored on hosted SaaS deployments. A SteelEngine-hosted deployment dedicated to one customer can opt in with EGRESS_ALLOWLIST_HOSTED_DATABASES=true on the app and the Worker; self-hosted deployments never need it. MySQL, MongoDB, Neo4j, Redis, SFTP, SSH, SMTP, and IMAP remain outside this feature because their connection pinning has not been verified here.
  • Allowed database connections emit Database egress allowlist permitted connection through EgressAudit at INFO, with scheme, host, port, all resolved addresses, matching entries, and workflow/workspace identity when supplied by the execution context. No database credentials are logged.

Set the same value on the web app and Temporal Worker, then restart both. A missing database CIDR or unsupported scheme fails startup. Verify a connection from each execution service and inspect the audit log; then verify that another private host or port remains blocked. Remove a database entry and restart both services to revoke the exception. INTERNAL_TARGET_ALLOWLIST is not used.

Authentication and Access

Sign-up is invitation-only and has no setting. An account is created from an invitation link, by an administrator (the admin API with ADMIN_API_KEY), or by SSO just-in-time provisioning. The invitee opens the emailed link, then signs up with the invited address by email or with Google; the invitation must still be pending. On a new install with no accounts, the first sign-up needs no invitation, so you can create the first admin. DISABLE_INVITATIONS controls workspace invitations; it is not a global switch that disables account creation from every invitation type.

This also accepts active credential-set invitations addressed to a specific email: the invitee opens /credential-account/<token> and signs up with that address. Shared credential invitation links without an addressee require an existing account. The browser's proof of opening an invitation lasts one hour; reopen the link if it expires. The invitation itself must still be pending and unexpired when the account is created.

Email and password, Google, and SSO are the sign-in methods. Other OAuth providers, GitHub included, only connect integrations to a signed-in account.

VariableDescription
API_ENCRYPTION_KEYEncrypts stored API keys (32 hex chars): openssl rand -hex 32. Set the same value on the app and the Worker
ADMIN_API_KEYAdmin API key for GitOps and organization management (32+ chars). Sent as x-admin-key
WORKLOAD_AUTH_ENABLEDDefaults to false. Set true on web and all workers to enable self-hosted Entra application authentication. Configure trust before enabling; redeploy both processes after changes. See Entra workload identities
WORKLOAD_AUTH_PROFILEJSON with exactly id, tenantId, audience, applicationIdUri, role. One global/commercial Entra tenant, resource API audience and required app role per installation. Required when workload auth is enabled; independent of human SSO/SCIM. Keep web and worker values consistent. The organization dashboard manages application bindings and local grants
DISABLE_AUTHtrue bypasses authentication and gives every request an anonymous session. Use it on private networks only. Ignored when the app URL is a steelengine.com host. Set it on realtime too
ALLOWED_LOGIN_DOMAINSOptional; only for single-customer deployments. Comma-separated email domains allowed to sign up and sign in, by every method, including Google and SSO, on top of the invitation rule. Matching ignores case; a domain entry does not include its subdomains. Existing users outside the list can no longer sign in. A session they already hold keeps working until it is revoked or goes 30 days unused, so revoke those sessions after narrowing the list. Leave it unset to allow any domain. Admins can still create accounts and impersonate users outside the list
SIGNUP_EMAIL_VALIDATION_ENABLEDtrue rejects disposable email domains at signup
EMAIL_PASSWORD_SIGNUP_ENABLED, NEXT_PUBLIC_EMAIL_PASSWORD_SIGNUP_ENABLEDfalse disables email/password sign-in and sign-up on the server and hides the email/password form. Disabled authentication requests return 403. Use with SSO
TURNSTILE_SECRET_KEY, NEXT_PUBLIC_TURNSTILE_SITE_KEYCloudflare Turnstile keys. Leave both unset to disable the captcha
ADDITIONAL_TRUSTED_ORIGINSComma-separated extra browser origins. Better Auth trusts them, /api/* allows them for credentialed CORS alongside the app URL, and /api/mcp/serve/* allows them for CORS
ALLOWED_ORIGINSRealtime server only. Comma-separated extra CORS origins beyond the app URL

Removed in this release

These variables no longer do anything. A deployment that still sets them starts normally and ignores them; remove them when convenient.

  • DISABLE_REGISTRATION: nothing to replace it. Sign-up is always invitation-only.
  • ALLOWED_LOGIN_EMAILS: invite those people instead. To limit a single-customer deployment to its company, set ALLOWED_LOGIN_DOMAINS.
  • BLOCKED_SIGNUP_DOMAINS: nothing to replace it. Nobody signs up without an invitation.
  • EMAIL_VERIFICATION_ENABLED: nothing to replace it. Opening the invitation link proves the address, so verification codes and the /verify page are gone.
  • DISABLE_GITHUB_AUTH: nothing to replace it. GitHub is not a sign-in method; GITHUB_CLIENT_ID and GITHUB_CLIENT_SECRET configure only the GitHub integration. An account that only ever signed in with GitHub resets its password from the login page, or signs in with Google when Google uses the same address.

Feature Toggles

Hosted plans gate these features by subscription. A self-hosted deployment enables them directly. Each server-side flag has a NEXT_PUBLIC_ twin that shows the matching UI. See Enterprise for what each feature does.

VariableDescription
ORGANIZATIONS_ENABLED, NEXT_PUBLIC_ORGANIZATIONS_ENABLEDOrganizations. Also on when BILLING_ENABLED or ACCESS_CONTROL_ENABLED is on
ACCESS_CONTROL_ENABLED, NEXT_PUBLIC_ACCESS_CONTROL_ENABLEDPermission groups. Turns organizations on as well
CREDENTIAL_SETS_ENABLED, NEXT_PUBLIC_CREDENTIAL_SETS_ENABLEDCredential sets for email polling triggers
INBOX_ENABLED, NEXT_PUBLIC_INBOX_ENABLEDSteelEngine Mailer on self-hosted, regardless of plan. The NEXT_PUBLIC_ twin shows Mailer in Settings. Needs AGENTMAIL_API_KEY
SSO_ENABLED, NEXT_PUBLIC_SSO_ENABLEDSingle sign-on. See SSO
DISABLE_INVITATIONS, NEXT_PUBLIC_DISABLE_INVITATIONStrue turns off workspace invitations everywhere
DISABLE_PUBLIC_API, NEXT_PUBLIC_DISABLE_PUBLIC_APItrue removes the public API toggle from workflows
E2B_ENABLED, E2B_API_KEY, NEXT_PUBLIC_E2B_ENABLEDRemote E2B sandboxes for Python Function blocks and JavaScript that imports packages. Set E2B_ENABLED and E2B_API_KEY on both the app and the Worker, since Function blocks run in the Worker. Without E2B, those blocks fail; plain JavaScript runs in a local VM
CODE_RUNNER_URL, CODE_RUNNER_TOKENWorker only. Runs Python Function blocks and JavaScript that imports packages in your own code runner service (docker/code-runner.Dockerfile) instead of E2B, so the code and its data stay in your environment. CODE_RUNNER_TOKEN is required with the URL and must match the runner's RUNNER_TOKEN. The runner has Python's standard library plus requests, and Node's built-in modules; code that needs other packages still needs E2B. Copilot's table files always use E2B. Run the runner under a VM-isolating runtime such as Kata Containers or gVisor
BILLING_ENABLED, NEXT_PUBLIC_BILLING_ENABLEDBilling enforcement and usage tracking. See Billing and Email

Landing Pages

VariableDescription
NEXT_PUBLIC_LANDING_ENABLEDfalse redirects the homepage and marketing routes such as /blog, /integrations, and /models to /login. true enables them. When unset, enabled for steelengine.com and its subdomains except customer hosts matching sig-*.steelengine.com; disabled for other hosts. The host comes from NEXT_PUBLIC_APP_URL

Set this under app.env in Helm. It controls the marketing pages; authentication and registration use the separate settings above.

SSO

SSO_ENABLED and NEXT_PUBLIC_SSO_ENABLED turn the feature on. Register the provider itself with bun run packages/db/scripts/register-sso-provider.ts. The script reads:

VariableDescription
SSO_PROVIDER_TYPEoidc or saml
SSO_PROVIDER_IDIdentifier used in callback URLs
SSO_ISSUERIdentity provider issuer URL
SSO_DOMAINEmail domain routed to this provider
SSO_USER_EMAILExisting user who owns the registration
SSO_ORGANIZATION_IDOptional organization to attach the provider to
SSO_OIDC_CLIENT_ID, SSO_OIDC_CLIENT_SECRETOIDC client. Endpoints come from discovery unless SSO_OIDC_*_ENDPOINT overrides them
SSO_SAML_ENTRY_POINT, SSO_SAML_CERTSAML IdP SSO URL and signing certificate. SSO_SAML_CALLBACK_URL, SSO_SAML_AUDIENCE, and metadata are optional
SSO_MAPPING_ID, SSO_MAPPING_EMAIL, SSO_MAPPING_NAME, SSO_MAPPING_IMAGEClaim mappings. Defaults fit standard OIDC and SAML claims

Set SSO_ENABLED=true after the script succeeds. packages/db/scripts/deregister-sso-provider.ts removes a provider.

In the app, only platform admins (users whose role is admin) can register, change, or remove a provider, whether in Organization Settings → SSO or through the /api/auth/sso/* endpoints that write providers. Organization admins see the active connection but cannot edit it.

Database, Redis, Realtime, and Storage

VariableDescription
DATABASE_POOL_MAXConnections per process. Compose sets 20 for the app and 25 for the Worker
DATABASE_LOCK_TIMEOUT_MS, DATABASE_STATEMENT_TIMEOUT_MSPer-session PostgreSQL timeouts. Compose sets 5,000 and 30,000 for the app, 5,000 and 60,000 for the Worker
DATABASE_MAX_LIFETIME_SECONDSSeconds before each pooled connection is closed and replaced, after any running query finishes (1 to 86,400). Unset keeps the client default of 30 to 60 minutes. Behind PgBouncer, set it well below pgbouncer.terminationGracePeriodSeconds so connections leave a stopping PgBouncer pod before it is killed
DATABASE_SESSION_URLDirect database URL for work that needs one server session, such as advisory locks. Set it when DATABASE_URL goes through a transaction pooler. The Helm chart sets it on the app when pgbouncer.enabled is on
REDIS_URLOptional. Enables the cross-pod Socket.IO adapter on realtime and caching on the app and Worker. Temporal, not Redis, carries the job queues
SOCKET_SERVER_URLServer-side URL the app uses to reach realtime (Compose default: http://realtime:3002)
INTERNAL_API_BASE_URLServer-side base URL for the app's own API calls. The Helm chart requires it when the Worker is enabled. Must be HTTPS with the production credential broker
STEELENGINE_LOCAL_STORAGE_ROOTDirectory for uploads when neither S3 nor Azure is configured (default: ./uploads in the process working directory)
AWS_REGION, S3_BUCKET_NAMEBoth set selects S3 storage. Credentials come from S3_ACCESS_KEY_ID and S3_SECRET_ACCESS_KEY (storage-scoped), AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY, or the AWS default chain
S3_ENDPOINT, S3_FORCE_PATH_STYLES3-compatible endpoint such as MinIO. Path style defaults to on when an endpoint is set
S3_KB_BUCKET_NAME, S3_EXECUTION_FILES_BUCKET_NAME, S3_CHAT_BUCKET_NAME, S3_PROFILE_PICTURES_BUCKET_NAME, S3_OG_IMAGES_BUCKET_NAMEPer-purpose buckets. Execution files default to steelengine-execution-files
AZURE_STORAGE_CONTAINER_NAME with AZURE_ACCOUNT_NAME and AZURE_ACCOUNT_KEY, or AZURE_CONNECTION_STRINGSelects Azure Blob storage. Azure wins when both S3 and Azure are configured
AZURE_STORAGE_KB_CONTAINER_NAME, AZURE_STORAGE_EXECUTION_FILES_CONTAINER_NAME, AZURE_STORAGE_CHAT_CONTAINER_NAME, AZURE_STORAGE_PROFILE_PICTURES_CONTAINER_NAME, AZURE_STORAGE_OG_IMAGES_CONTAINER_NAMEPer-purpose containers, mirroring the S3 buckets

The published images run with NODE_ENV=production. The database pool then requires TLS unless DATABASE_URL carries ?sslmode=disable. Storage variables must match on the app and the Worker. The Worker writes execution files and knowledge base content with the same rules.

Limits and Timeouts

The execution timeout variables below provide defaults for workflows whose Execution timeout setting is blank. A per-workflow override replaces that execution budget with a hard elapsed-time limit, including waits and approval pauses. Clearing it restores the defaults for new runs.

Defaults are shown per plan tier. Values are strings. When billing is disabled, plan tiers do not apply. Every execution uses the enterprise rate limits (defaults: 600 sync, 5000 async, and 500 API endpoint requests per minute; RATE_LIMIT_ENTERPRISE_SYNC and RATE_LIMIT_ENTERPRISE_ASYNC override the first two). Workflows without a timeout override use the enterprise execution timeouts. Every workspace gets the enterprise table limits (10,000 tables of up to 1,000,000 rows each), storage caps are off, and workspace concurrency uses WORKSPACE_CONCURRENCY_ENTERPRISE (default 200). Raise EXECUTION_TIMEOUT_ENTERPRISE or EXECUTION_TIMEOUT_ASYNC_ENTERPRISE if runs need longer. Workflows the Chat assistant or an MCP client runs and waits on are limited to 10 minutes; set COPILOT_MCP_SYNC_TIMEOUT_MS (milliseconds) to change that.

VariableDescription
RATE_LIMIT_WINDOW_MSRate limit window (default: 60000)
RATE_LIMIT_FREE_SYNC, RATE_LIMIT_FREE_ASYNCAPI executions per window (defaults: 50, 200)
RATE_LIMIT_PRO_SYNC, RATE_LIMIT_PRO_ASYNCDefaults: 150, 1000
RATE_LIMIT_TEAM_SYNC, RATE_LIMIT_TEAM_ASYNCDefaults: 300, 2500
RATE_LIMIT_ENTERPRISE_SYNC, RATE_LIMIT_ENTERPRISE_ASYNCDefaults: 600, 5000
MCP_RATE_LIMIT_BURST, MCP_RATE_LIMIT_PER_MINUTESteelEngine MCP requests per user: how many can arrive at once, then how many per minute after that (defaults: 60, 30). Over the limit, the MCP endpoint returns HTTP 429 with Retry-After
EXECUTION_TIMEOUT_FREE, EXECUTION_TIMEOUT_PRO, EXECUTION_TIMEOUT_TEAM, EXECUTION_TIMEOUT_ENTERPRISEDefault synchronous execution timeout in seconds when the workflow has no override (defaults: 300, then 3000)
EXECUTION_TIMEOUT_ASYNC_FREE and the _PRO, _TEAM, _ENTERPRISE variantsDefault asynchronous execution timeout in seconds when the workflow has no override (default: 5400)
WORKSPACE_CONCURRENCY_FREE, _PRO, _TEAM, _ENTERPRISEConcurrent executions per workspace (defaults: 5, 50, 200, 200)
ADMISSION_GATE_MAX_INFLIGHTIn-flight execution requests per app process (default: 500)
EXECUTION_ADMISSION_POLICY_MODE, EXECUTION_ADMISSION_FIXED_PROFILE, EXECUTION_ADMISSION_ROLLOUT_MODE, EXECUTION_ADMISSION_CONCURRENCY_ENABLEDExecution admission policy. Set identical values on the app and the Worker. helm/steelengine/values.yaml lists the accepted values
FREE_STORAGE_LIMIT_GB, PRO_STORAGE_LIMIT_GB, TEAM_STORAGE_LIMIT_GB, ENTERPRISE_STORAGE_LIMIT_GBStorage caps in GB (defaults: 5, 50, 500, 500)
IVM_POOL_SIZE, IVM_MAX_FETCH_RESPONSE_BYTES, IVM_MAX_STDOUT_CHARSFunction block sandbox pool size (default 4), fetch response cap (default 32 MiB), and captured stdout (default 200000 chars)
IVM_MAX_TOTAL_WORKERSFunction block sandbox processes, counting ones being recycled (default: twice IVM_POOL_SIZE). A recycled process finishes its running code while a replacement takes new work; this caps how many exist at once. Values below IVM_POOL_SIZE are raised to it, and a value equal to it makes new work wait for recycled processes to finish
IVM_CANCEL_GRACE_MSMilliseconds to wait for a local JavaScript worker to acknowledge cancellation, including cancellation after an execution deadline (default 1000). Set 0 to skip the grace period; negative values are treated as 0. If acknowledgement does not arrive in time, the worker is terminated and its other running executions also fail. This does not extend the code execution timeout

Local JavaScript execution capacity stays reserved until cancellation is acknowledged, the execution returns a result, or its worker exits. A worker that misses the parent execution deadline stops accepting new work; after acknowledging cancellation, it lets its other executions finish before retiring. A worker awaiting forced termination counts against IVM_MAX_TOTAL_WORKERS until its exit is confirmed. The local pool does not automatically replay failed executions. See Function block cancellation and recovery.

Run History Retention

Cron routes delete old run history, one bounded batch per call, so a large backlog clears over many runs. Runs that are paused or waiting for an approval are never deleted, and audit logs are not touched.

  • /api/logs/cleanup deletes execution logs with their traces and outputs. Workflow snapshot cleanup is suspended: root and child graph snapshots remain stored, including after their logs expire, so retained runs keep their child-workflow views. Both live cleanup and dry-run responses report results.snapshots.skipped: true. With S3 or Azure Blob storage it also deletes the files each run produced, under execution/<workspace>/<workflow>/<execution>/, and archives their execution file records. Files a run only referenced, such as workspace documents, are never deleted, and their records are never changed. Before deleting a run it writes a copy to logs/archived/<date>/<log id>.json in the files bucket; nothing reads those copies, so give that prefix a lifecycle rule that expires it (SteelEngine Cloud uses 7 days).
  • /api/cron/execution-retention deletes old Temporal journals and finished checkpoint chains and does nothing else.
  • /api/cron/cleanup-stale-executions runs the same journal and checkpoint retention, plus the stale-run and admission reconcilers.

In Helm, cronjobs.jobs.cleanupExecutionLogs runs /api/logs/cleanup and is off by default; cleanupStaleExecutions runs /api/cron/cleanup-stale-executions every five minutes. Retention runs under a Postgres advisory lock in every route, so a run that overlaps another skips it; /api/logs/cleanup and /api/cron/execution-retention then return {"skipped": true}. Each retention statement waits at most 5 seconds for a row lock and runs at most 60 seconds, whatever DATABASE_LOCK_TIMEOUT_MS and DATABASE_STATEMENT_TIMEOUT_MS say. A row another session holds makes that batch give up with a warning, and a later run retries it. Add ?dryRun=1 to /api/logs/cleanup or /api/cron/execution-retention to see what the next run would delete without deleting anything, and check that before enabling a schedule:

curl -H "Authorization: Bearer $CRON_SECRET" "$APP_URL/api/logs/cleanup?dryRun=1"

A journal is the detailed execution record behind a run. Once it is deleted, GET /api/jobs/{id} answers from run history, and promotion validation can no longer cite the run.

VariableDescription
LOG_RETENTION_DAYSDays to keep run history after a run finishes, for every workspace (default 90, from 1 to 3650)
TEMPORAL_EXECUTION_CHECKPOINT_RETENTION_DAYSDays to keep a finished run's checkpoint chain (default 90, minimum 30). A chain that a kept log's trace view still reads stays until that log is deleted
TEMPORAL_EXECUTION_JOURNAL_RETENTION_DAYSDays to keep a finished run's private Temporal journal (default 30, minimum 7). Cleanup first copies the run's version label onto its log, so the Logs page still shows it
TEMPORAL_EXECUTION_JOURNAL_CLEANUP_BATCH_SIZE, TEMPORAL_EXECUTION_CHECKPOINT_CLEANUP_BATCH_SIZEJournals (default 250, at most 1000) and checkpoint chains (default 25, at most 100) one cleanup run may delete

An organization can keep run history longer than LOG_RETENTION_DAYS, never shorter: cleanup applies whichever is longer. Set it from packages/db with DATABASE_URL pointing at the deployment's database:

bun run ./scripts/run-history-retention.ts set <organizationId> 365
bun run ./scripts/run-history-retention.ts status <organizationId>
bun run ./scripts/run-history-retention.ts clear <organizationId>

FREE_PLAN_LOG_RETENTION_DAYS was removed. It shortened retention for Community-plan workspaces when billing was enabled. A deployment that still sets it starts normally; cleanup ignores it and logs a warning.

Billing and Email

VariableDescription
BILLING_ENABLED, NEXT_PUBLIC_BILLING_ENABLEDTurn on Stripe billing and usage enforcement, including plan-tier rate limits and timeouts. With billing disabled, every workspace gets the enterprise limits. Most self-hosted deployments leave both unset
STRIPE_SECRET_KEY, STRIPE_WEBHOOK_SECRETStripe API and webhook credentials
STRIPE_PRICE_TIER_BUILDER_MO, STRIPE_PRICE_TIER_TEAM_MO, STRIPE_PRICE_TIER_SCALE_MO and the _YR variantsStripe price IDs for the self-serve plans
COST_MULTIPLIERMultiplier for cost calculations
SENDGRID_API_KEYSendGrid API key. When set, every email SteelEngine sends goes through SendGrid, including workflow notification emails from the Temporal Worker. It takes precedence over Resend and Azure, and there is no fallback: a failed SendGrid send is logged and not retried on another provider. Verify the FROM_EMAIL_ADDRESS (or noreply@ your EMAIL_DOMAIN) and PERSONAL_EMAIL_FROM senders in SendGrid, or authenticate their domain
RESEND_API_KEYResend API key for transactional email
AZURE_ACS_CONNECTION_STRINGAzure Communication Services. Used as the fallback when Resend fails, or alone when Resend is unset
FROM_EMAIL_ADDRESSComplete sender address, e.g. SteelEngine <noreply@yourdomain.com>
EMAIL_DOMAINSender domain used when FROM_EMAIL_ADDRESS is not set
PERSONAL_EMAIL_FROMSender for personalized emails
EMAIL_FROMSender for workflow notification emails the Temporal Worker sends through Resend (default: SteelEngine <noreply@steelengine.app>). Ignored when SENDGRID_API_KEY is set. docker/selfhost/compose.yml sets it to FROM_EMAIL_ADDRESS when you leave it unset
TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, TWILIO_PHONE_NUMBERSMS sending
AGENTMAIL_API_KEYAgentMail API key for the SteelEngine Mailer. Mailer fails with AGENTMAIL_API_KEY is not configured without it
AGENTMAIL_DOMAINOptional domain for Mailer inbox addresses (default: agentmail.to)

With none of SENDGRID_API_KEY, RESEND_API_KEY or AZURE_ACS_CONNECTION_STRING set, SteelEngine sends no email. It logs Email not sent (no email service configured) together with any verification or reset link. Copy the link from the logs.

SteelEngine turns off SendGrid click, open, subscription and Google Analytics tracking on its emails, so verification and reset links reach recipients unchanged.

The Temporal Worker reads the same SENDGRID_API_KEY, FROM_EMAIL_ADDRESS and EMAIL_DOMAIN. The Helm chart and docker/selfhost/compose.yml pass them to the Worker for you. Compose also passes RESEND_API_KEY to the app and the Worker, and EMAIL_FROM to the Worker. If you use app.secrets.existingSecret or External Secrets, add SENDGRID_API_KEY to that Secret; both pods load it.

Branding

All branding variables are NEXT_PUBLIC_ values. The Helm chart sets them under app.env. Colors must be six-digit hex.

VariableDescription
NEXT_PUBLIC_BRAND_NAMEProduct name shown in the UI (default: SteelEngine)
NEXT_PUBLIC_BRAND_LOGO_URLSquare icon for the collapsed sidebar
NEXT_PUBLIC_BRAND_WORDMARK_URLWide wordmark for the expanded sidebar
NEXT_PUBLIC_BRAND_FAVICON_URLFavicon
NEXT_PUBLIC_BRAND_PRIMARY_COLOR, NEXT_PUBLIC_BRAND_PRIMARY_HOVER_COLORPrimary color and hover state, #RRGGBB
NEXT_PUBLIC_BRAND_ACCENT_COLOR, NEXT_PUBLIC_BRAND_ACCENT_HOVER_COLORAccent color and hover state, #RRGGBB
NEXT_PUBLIC_BRAND_BACKGROUND_COLORBackground color, #RRGGBB
NEXT_PUBLIC_CUSTOM_CSS_URLExtra stylesheet loaded after the app's own
NEXT_PUBLIC_SUPPORT_EMAILSupport address shown in the UI (default: support@steelengine.com)
NEXT_PUBLIC_DOCUMENTATION_URL, NEXT_PUBLIC_TERMS_URL, NEXT_PUBLIC_PRIVACY_URLReplace the documentation, terms, and privacy links

On Kubernetes, branding.enabled in the Helm chart mounts logo and CSS files at /app/public/branding so these URLs can point at the app itself.

Example .env

BETTER_AUTH_SECRET=<openssl rand -hex 32>
ENCRYPTION_KEY=<openssl rand -hex 32>
INTERNAL_API_SECRET=<openssl rand -hex 32>
TEMPORAL_WORKER_BROKER_SECRET=<a different openssl rand -hex 32 value>
POSTGRES_PASSWORD=<openssl rand -hex 16>
NEXT_PUBLIC_APP_URL=https://steelengine.yourdomain.com
BETTER_AUTH_URL=https://steelengine.yourdomain.com
NEXT_PUBLIC_SOCKET_URL=https://steelengine.yourdomain.com
TEMPORAL_WORKER_APP_URL=https://steelengine.yourdomain.com
TEMPORAL_ADDRESS=temporal.yourdomain.com:7233
TEMPORAL_NAMESPACE=steelengine-production
TEMPORAL_SERVER_NAME=temporal.yourdomain.com
TEMPORAL_AUTH_ISSUER=https://steelengine.yourdomain.com
TEMPORAL_AUTH_JWKS_URL=https://steelengine.yourdomain.com/api/auth/jwks
TEMPORAL_BUILD_ID=<image digest or git sha>
OPENAI_API_KEY=sk-...

See apps/web/.env.example for more options.

On this page