---
title: "Deploy Outline | (Just Updated) Notion Alternative Team Wiki, Admin Login Pre-Created, No S3 Needed"
description: "Outline team wiki and knowledge base, a Notion alternative, login included"
category: "Other"
url: https://railway.com/deploy/outline-or-just-updated-notion-alternati
---

# Deploy Outline | (Just Updated) Notion Alternative Team Wiki, Admin Login Pre-Created, No S3 Needed

Outline team wiki and knowledge base, a Notion alternative, login included

**[Deploy Outline | (Just Updated) Notion Alternative Team Wiki, Admin Login Pre-Created, No S3 Needed on Railway](https://railway.com/template/outline-or-just-updated-notion-alternati)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/outline-or-just-updated-notion-alternati/manifest.json

- **Creator:** SuperSlowSloth
- **Category:** Other

## Template content

### outline

- **Image:** ghcr.io/bon5co/outline-railway:1.13.0@sha256:5604d31c26b4d18a7a17f1e9a47e6e4aa7b5c9bbf8ec7003c572497c76b3dcc0
- **Health check:** /_health
- **Public domain:** Yes

### database

- **Image:** postgres:17@sha256:b60e90042aa6b8dbecd58e224b3e36114dbf8ad754465264c2476ad58a86e45c

### cache

- **Image:** redis:8.2.1-alpine@sha256:987c376c727652f99625c7d205a1cba3cb2c53b92b0b62aade2bd48ee1593232
- **Start command:** `/bin/sh -c 'chown -R redis:redis /data && exec docker-entrypoint.sh redis-server --requirepass "$REDIS_PASSWORD" --appendonly yes --dir /data'`

## Documentation

# Deploy and Host Outline on Railway

**Built for an LLM agent to deploy and use.** The deploy form has no fields to fill: the administrator login, the secrets and the database credentials are generated, a sign-in provider is already wired in, attachments are stored on a volume so no S3 bucket is needed, and nobody else can register. Outline is an open-source team knowledge base and wiki with nested collections, real-time collaboration, Markdown, search and a full API, a self-hosted alternative to Notion and Confluence.

## About Hosting Outline

This template runs three services: **outline**, the official `outlinewiki/outline` image (release 1.13.0) pinned by digest through a thin wrapper, with a volume at `/var/lib/outline/data` for uploaded files; **database**, a PostgreSQL 17 instance with a volume at `/var/lib/postgresql`; and **cache**, a Redis instance with a volume at `/data`. One public domain serves Outline on port 8080, with an HTTP healthcheck at `/_health` that turns green only after the database migrations ran and both the app and its sign-in provider answer.

**What the wrapper fixes.** Outline has no password sign-in: it needs an OpenID Connect provider or an e-mailed magic link, so a stock deploy cannot be signed in to until someone configures one, and the most used Railway listing also leaves the S3 settings blank. The wrapper bundles [Dex](https://github.com/dexidp/dex) (release 2.46.1, pinned by digest) as the provider with one static account whose e-mail and password are `ADMIN_EMAIL` and `ADMIN_PASSWORD` (stored as a bcrypt hash computed at boot), runs the database migrations, and opens one public port: `/dex` goes to Dex, everything else to Outline, websockets included. Dex has no registration page, so no stranger can create an account. The first sign-in with the generated login creates the workspace and makes that account its administrator. Redeploys keep the account, the documents and the uploads.

**Using it.** Open your domain, press the sign-in button and enter the administrator e-mail and password. Create an API key under Settings, API, or through the API as below, and an agent can create and read documents with it. E-mail notifications, Slack and other integrations are not configured; set their variables on the `outline` service if you need them.

### Agent contract

- Public URL: `https://RAILWAY_PUBLIC_DOMAIN` (the generated domain of the `outline` service)
- Private URL: `http://outline.railway.internal:8080`
- Credentials: the variables `ADMIN_EMAIL` and `ADMIN_PASSWORD` on the `outline` service (plain text); the Outline API key is created after sign-in
- Auth: `GET /auth/oidc` leads to the Dex form, which takes `login` and `password` and ends in Outline with session cookies; on writes made with the cookie session send the `__Host-csrfToken` cookie value in an `x-csrf-token` header; `POST /api/apiKeys.create` returns a key to send as `Authorization: Bearer KEY` on every `/api` call, which answers 401 without it
- Health: `GET /_health` returns 200 without credentials

```bash
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, ADMIN_EMAIL, ADMIN_PASSWORD (variables of the outline service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; H="content-type: application/json"; JAR=$(mktemp)
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/_health")" = 200 ]; do n=$((n+1)); [ "$n" -le 90 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/_health"
# sign-in goes through the bundled Dex login: following /auth/oidc lands on the Dex form, whose URL is also where the form posts
FORM=$(curl -s -c "$JAR" -b "$JAR" -L -o /dev/null -w '%{url_effective}' "$R/auth/oidc")
# Dex has no registration: any identity other than the generated account is refused
NOPE="not-the-real-one-1"
curl -s -o /dev/null -w "public signup: %{http_code}\n" --data-urlencode "login=stranger@example.com" --data-urlencode "password=$NOPE" "$FORM"
curl -s -o /dev/null -w "wrong login: %{http_code}\n" --data-urlencode "login=$ADMIN_EMAIL" --data-urlencode "password=$NOPE" "$FORM"
# the generated login: the redirects end in Outline with a session cookie, and the first sign-in creates the workspace
curl -s -c "$JAR" -b "$JAR" -L -o /dev/null -w "login: %{http_code}\n" --data-urlencode "login=$ADMIN_EMAIL" --data-urlencode "password=$ADMIN_PASSWORD" "$FORM"
# over HTTPS the cookie is named __Host-csrfToken; its value goes back in the x-csrf-token header on writes made with the cookie session
CSRF=$(awk '$6 ~ /csrfToken$/{print $7}' "$JAR")
echo "role: $(curl -s -b "$JAR" -X POST -H "$H" -H "x-csrf-token: $CSRF" "$R/api/auth.info" | jq -r '.data.user.role')"
# an API key for the agent: Bearer KEY authenticates every /api call after this
KEY=$(curl -s -b "$JAR" -H "$H" -H "x-csrf-token: $CSRF" -d '{"name":"agent"}' "$R/api/apiKeys.create" | jq -r '.data.value')
COL=$(curl -s -H "authorization: Bearer $KEY" -H "$H" -d '{}' "$R/api/collections.list" | jq -r '.data[0].id')
BODY=$(jq -nc --arg c "$COL" '{title:"hello",text:"from an agent",collectionId:$c,publish:true}')
# write-auth: POST /api/documents.create needs the key; without it, or with a wrong one, the answer is 401
curl -s -o /dev/null -w "write with key: %{http_code}\n" -H "authorization: Bearer $KEY" -H "$H" -d "$BODY" "$R/api/documents.create"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$H" -d "$BODY" "$R/api/documents.create"
curl -s -o /dev/null -w "write wrong key: %{http_code}\n" -H "authorization: Bearer ol_api_wrong" -H "$H" -d "$BODY" "$R/api/documents.create"
```

Expected output against a fresh deploy:

```text
health: 200
public signup: 401
wrong login: 401
login: 200
role: admin
write with key: 200
write without key: 401
write wrong key: 401
```

The refusals are the contract: a request without a key is refused (`write without key: 401`), a stranger cannot register (`public signup: 401`) and a wrong password is refused (`wrong login: 401`).

## Why Deploy Outline 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 Outline 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 key.
- **Sign-in included** - a pre-wired login, so there is no OIDC provider or mail server to set up first.
- **No S3 bucket** - uploads live on a volume at `/var/lib/outline/data`.
- **Data survives redeploys** - documents in PostgreSQL on a volume, uploads on a volume, Redis on a volume.
- **Pinned** - Outline, Dex, PostgreSQL and Redis are pinned by digest, and the wrapper by tag and digest.

## Common Use Cases

- **Team wiki** - one searchable home for runbooks, specs and meeting notes, instead of a Notion or Confluence subscription.
- **Documentation for a product** - collections and nested documents with a public share link per page.
- **Memory for AI agents** - give an agent a generated login and an API key to write and read the notes it needs between tasks.

## Dependencies for Outline Hosting

- The outline service, a PostgreSQL service and a Redis service, each with its volume, created by the template.

### Deployment Dependencies

- [Outline repository](https://github.com/outline/outline)
- [Dex repository](https://github.com/dexidp/dex)
- [Wrapper image source](https://github.com/bon5co/outline-railway)


## Similar templates

- [Rocky Linux](https://railway.com/deploy/rocky-linux) — Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀
- [Foundry Virtual Tabletop](https://railway.com/deploy/X5tR6G) — Self-hosted virtual tabletop for role-playing games (license required)
- [Double Commander in your browser](https://railway.com/deploy/double-commander-in-your-browser) — The Double Commander file manager in the cloud, from any device

Open this page in a browser: https://railway.com/deploy/outline-or-just-updated-notion-alternati
