
Deploy OneUptime | (Just Updated) Open-Source Datadog and Pingdom Alternative, Admin Login Pre-Created, Sign-up Closed
OneUptime uptime monitoring, status page, incidents, on-call and OTLP logs
Just deployed
/var/lib/clickhouse
Just deployed
Just deployed
/data
oneuptime
Just deployed
database
Just deployed
/var/lib/postgresql
Deploy and Host OneUptime on Railway
Built for an LLM agent to deploy and use. The deploy form has no fields to fill: the owner login, every secret and the three databases' credentials are generated, the first account is created before the site is reachable, and sign-up is switched off afterwards. OneUptime is an open-source observability platform with uptime monitoring, status pages, incident management, on-call, logs, traces, metrics and an OpenTelemetry (OTLP) ingest endpoint, a self-hosted alternative to Datadog, Pingdom and StatusPage.
About Hosting OneUptime
This template runs five services: oneuptime, the official oneuptime/app image (release 17.1.0) pinned by digest through a thin wrapper, which owns the one public domain on port 8080 with an HTTP healthcheck at /status/ready; probe, the stock OneUptime probe that runs the uptime checks; database, PostgreSQL 15 with a volume at /var/lib/postgresql; cache, Valkey with a volume at /data; and clickhouse, ClickHouse set up as a single node with a volume at /var/lib/clickhouse, where logs, traces and metrics live.
What the wrapper fixes. Stock OneUptime makes whoever reaches the sign-up form first the Master Admin, and its sign-up switch lives in a database row that the dashboard flips by hand. The wrapper runs the database migrations, creates the owner account from ADMIN_EMAIL and ADMIN_PASSWORD before the public port opens, turns sign-up off in the database, and only then lets traffic in through a small proxy on the injected PORT. A stranger who reaches the domain finds the account taken and registration closed. Redeploys keep the owner, the projects and the monitors.
Using it. Open your domain and sign in with the owner e-mail and password, then create a project; the probe in this template is already registered, so a monitor you add (a website, an API, a port) starts reporting at once. Applications send OpenTelemetry data to https://YOUR_DOMAIN/otlp with a project telemetry key made in the dashboard. An agent can create projects through the API as below. E-mail (invites, alerts by mail), SMS and OAuth sign-in are not configured; set their variables on the oneuptime service if you need them.
Agent contract
- Public URL:
https://RAILWAY_PUBLIC_DOMAIN(the generated domain of theoneuptimeservice) - Private URL:
http://oneuptime.railway.internal:3002(the app itself, without the sign-up guard; the public port 8080 is the guarded front door) - Credentials: the variables
ADMIN_EMAILandADMIN_PASSWORDon theoneuptimeservice (plain text) - Auth:
POST /api/identity/loginwith a JSON body of the e-mail and password wrapped in adataobject sets the session cookies; send them on every API call, and API routes answer 401 without them - Health:
GET /status/readyreturns 200 without credentials
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, ADMIN_EMAIL, ADMIN_PASSWORD (variables of the oneuptime service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; H="content-type: application/json"; JAR=$(mktemp)
NOPE="not-the-real-one-1"
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/status/ready")" = 200 ]; do n=$((n+1)); [ "$n" -le 120 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/status/ready"
# the owner exists already and sign-up is switched off: a stranger's sign-up is refused
curl -s -o /dev/null -w "public signup: %{http_code}\n" -H "$H" -d "$(jq -nc --arg p "$NOPE" '{data:{email:{_type:"Email",value:"stranger@example.com"},name:{_type:"Name",value:"X"},password:$p}}')" "$R/api/identity/signup"
curl -s -o /dev/null -w "wrong login: %{http_code}\n" -H "$H" -d "$(jq -nc --arg e "$ADMIN_EMAIL" --arg p "$NOPE" '{data:{email:{_type:"Email",value:$e},password:$p}}')" "$R/api/identity/login"
# the generated login sets the session cookies
curl -s -c "$JAR" -o /dev/null -w "login: %{http_code}\n" -H "$H" -d "$(jq -nc --arg e "$ADMIN_EMAIL" --arg p "$ADMIN_PASSWORD" '{data:{email:{_type:"Email",value:$e},password:$p}}')" "$R/api/identity/login"
BODY="{\"data\":{\"name\":\"Agent $$\"}}"
# write-auth: POST /api/project needs the session cookie from the login; without it, or with a wrong one, the answer is 401
curl -s -b "$JAR" -o /dev/null -w "write with key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"
curl -s -H "cookie: user-token=not-a-real-token" -o /dev/null -w "write wrong key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/project"
Expected output against a fresh deploy:
health: 200
public signup: 403
wrong login: 400
login: 200
write with key: 200
write without key: 401
write wrong key: 401
The refusals are the contract: a request without a session is refused (write without key: 401), a stranger cannot register (public signup: 403) and a wrong password is refused (wrong login: 400). The first start takes a few minutes while OneUptime migrates PostgreSQL and ClickHouse; the loop at the top waits for it.
Why Deploy OneUptime 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 OneUptime 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.
- Agent-ready - no deployer fields, a contract block, and one script that proves the app is healthy, strangers cannot register, the generated login works and the API refuses writes without a session.
- Owner included - the first account is created before the site is reachable, so nobody can claim it.
- Probe included - a probe is registered at first start, so the first monitor you add already runs.
- Data survives redeploys - accounts in PostgreSQL on a volume, telemetry in ClickHouse on a volume, Valkey on a volume.
- Pinned - OneUptime, PostgreSQL, Valkey and ClickHouse are pinned by digest, and the wrapper by tag and digest.
Common Use Cases
- Uptime monitoring and a public status page - website, API and port checks with incident history, instead of a Pingdom or StatusPage subscription.
- Incident management and on-call - alerts, escalation rules and incident timelines in one place.
- Logs, traces and metrics - send OpenTelemetry data from your applications to one endpoint and query it in the dashboard.
- Observability for AI agents - give an agent a generated login to create projects and monitors for the services it deploys.
Dependencies for OneUptime Hosting
- The oneuptime and probe services, a PostgreSQL service, a Valkey service and a ClickHouse service, each stateful one with its volume, created by the template.
Deployment Dependencies
Template Content
database
postgres:15
