---
title: "Deploy Reactive Resume | (Just Updated) Open Source Resume Builder, API Key and Database Generated"
description: "Reactive Resume open source resume builder, CV maker with REST API"
category: "Other"
url: https://railway.com/deploy/reactive-resume-or-just-updated-open-sou
---

# Deploy Reactive Resume | (Just Updated) Open Source Resume Builder, API Key and Database Generated

Reactive Resume open source resume builder, CV maker with REST API

**[Deploy Reactive Resume | (Just Updated) Open Source Resume Builder, API Key and Database Generated on Railway](https://railway.com/template/reactive-resume-or-just-updated-open-sou)**

Machine-readable deploy manifest (JSON, validated by TemplateCI): https://railway.com/deploy/reactive-resume-or-just-updated-open-sou/manifest.json

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

## Template content

### reactive-resume

- **Image:** ghcr.io/bon5co/reactive-resume-railway:6.1.1@sha256:102d5cafc64273bf73e98971c496696de8054fd5cb909743afa4fa2a2c0d4ab8
- **Health check:** /api/health
- **Public domain:** Yes

### postgres

- **Image:** postgres:17.10-trixie

## Documentation

# Deploy and Host Reactive Resume on Railway

**Built for an LLM agent to deploy and use.** The deploy form has no fields to fill: the PostgreSQL password, the session secret, an administrator password and an API key are generated, the app URL is derived from the deploy's own domain, public sign-up is closed, and both the database and the uploads sit on volumes. Reactive Resume is the open-source resume builder: write, style and export a CV as PDF from a browser, with templates, sharing links and a REST API, a free alternative to hosted resume builders.

## About Hosting Reactive Resume

This template runs two services: **reactive-resume**, the upstream Reactive Resume 6.1.1 image (pinned by digest) through a thin wrapper, with a volume at `/app/data` for uploads, and **postgres** (PostgreSQL 17) with its volume at `/var/lib/postgresql`. One public domain serves the web app and the API. The listener is on Railway's injected `PORT`, and the healthcheck is `GET /api/health`.

**What the wrapper fixes.** A fresh upstream Reactive Resume needs `APP_URL` written by hand to match the public URL, leaves account registration open to the first visitor, and creates an API key only through the web UI after someone has signed up and logged in. Railway also mounts the uploads volume owned by root, which the app user cannot write. The wrapper derives `APP_URL` from `RAILWAY_PUBLIC_DOMAIN`, hands the volume to the app user, starts with sign-up and guest login switched off, waits for the app to apply its own migrations and then creates the administrator and an API key from the `ADMIN_PASSWORD` and `API_KEY` variables, so nothing has to be clicked.

**Using it.** The API key drives the instance over REST: list, create, read, update and delete resumes under `/api/openapi`, with the key in the `x-api-key` header. The browser works too: sign in as `admin@example.com` with `ADMIN_PASSWORD`. Because sign-up is closed, this one account is the only way in; set `FLAG_DISABLE_SIGNUPS=false` on the reactive-resume service to let people register. The administrator account is created once, so changing `ADMIN_PASSWORD` later does not change an existing password; changing `API_KEY` and redeploying replaces the stored key. Keep `AUTH_SECRET` stable: changing it signs every user out.

### Agent contract

- Public URL: `https://RAILWAY_PUBLIC_DOMAIN` (the generated domain of the `reactive-resume` service); the API is under `/api/openapi`
- Private URL: `http://reactive-resume.railway.internal:8080`; PostgreSQL at `postgres.railway.internal:5432`
- Credentials: the variable `API_KEY` on the `reactive-resume` service is the API key; `ADMIN_PASSWORD` is the password of the administrator `admin@example.com` for the web login; `AUTH_SECRET` signs sessions and is not a login; `DATABASE_URL` points at the `postgres` service
- Auth: send `x-api-key: API_KEY` on every `/api/openapi/*` call. A write with no key answers 401, a write with a wrong key answers 401, and public sign-up answers 403 for anonymous account creation and is refused for email sign-up (`EMAIL_PASSWORD_SIGN_UP_DISABLED`).
- Health: `GET /api/health` returns 200

```bash
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, API_KEY, ADMIN_PASSWORD (variables of the reactive-resume service); also curl, date, grep. Creates a throwaway resume and removes it again.
R="https://$RAILWAY_PUBLIC_DOMAIN"; J="Content-Type: application/json"; A="x-api-key: $API_KEY"
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/api/health")" = 200 ]; do n=$((n+1)); [ "$n" -le 60 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/api/health"
# read with the key
curl -s -o /dev/null -w "read resumes: %{http_code}\n" -H "$A" "$R/api/openapi/resumes"
# write with the key: create a throwaway resume, read it back in the list, remove it
N="agent-$(date +%s)"
ID=$(curl -s -X POST -H "$J" -H "$A" -d "{\"name\":\"$N\",\"slug\":\"$N\",\"tags\":[]}" "$R/api/openapi/resumes" | tr -d '"')
curl -s -o /dev/null -w "write resume: %{http_code}\n" -H "$A" "$R/api/openapi/resumes/$ID"
if curl -s -H "$A" "$R/api/openapi/resumes" | grep -q "$N"; then echo "read back: found"; else echo "read back: MISSING"; fi
curl -s -o /dev/null -w "delete resume: %{http_code}\n" -X DELETE -H "$A" "$R/api/openapi/resumes/$ID"
if curl -s -H "$A" "$R/api/openapi/resumes" | grep -q "$N"; then echo "after delete: STILL LISTED"; else echo "after delete: gone"; fi
# refusals: no key, wrong key, public sign-up (anonymous account creation and email sign-up), login with the generated administrator
curl -s -o /dev/null -w "write without key: %{http_code}\n" -X POST -H "$J" -d '{"name":"intruder","slug":"intruder","tags":[]}' "$R/api/openapi/resumes"
curl -s -o /dev/null -w "write wrong key: %{http_code}\n" -X POST -H "$J" -H "x-api-key: not-the-key" -d '{"name":"intruder","slug":"intruder","tags":[]}' "$R/api/openapi/resumes"
curl -s -o /dev/null -w "public signup: %{http_code}\n" -X POST -H "$J" -H "Origin: $R" -d '{}' "$R/api/auth/sign-in/anonymous"
if curl -s -X POST -H "$J" -H "Origin: $R" -d '{"name":"Intruder","email":"intruder@example.com","password":"intruder-pass-1234"}' "$R/api/auth/sign-up/email" | grep -q EMAIL_PASSWORD_SIGN_UP_DISABLED; then echo "email signup: refused"; else echo "email signup: OPEN"; fi
curl -s -o /dev/null -w "admin login: %{http_code}\n" -X POST -H "$J" -H "Origin: $R" -d "{\"email\":\"admin@example.com\",\"password\":\"$ADMIN_PASSWORD\"}" "$R/api/auth/sign-in/email"
```

Expected output against a fresh deploy (measured on a Railway deploy of the published template):

```text
health: 200
read resumes: 200
write resume: 200
read back: found
delete resume: 200
after delete: gone
write without key: 401
write wrong key: 401
public signup: 403
email signup: refused
admin login: 200
```

The refusals are the contract: `write without key: 401`, `write wrong key: 401`, `public signup: 403` and `email signup: refused` (no one can register). The first six lines show the key can read, write and delete, and `admin login: 200` shows the generated administrator password works in the browser.

## Why Deploy Reactive Resume 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 Reactive Resume 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 instance is healthy, the key can read, write and delete, and unauthenticated writes and public sign-up are refused.
- **Setup done for you** - URL, volume permissions, administrator and API key are in place before the first visitor can reach the instance.
- **Sign-up closed** - nobody can register on your instance unless you switch it on.
- **Data survives redeploys** - resumes live in PostgreSQL on a volume and uploads on a second one.
- **Pinned** - the upstream image is pinned by digest and the wrapper by tag and digest.

## Common Use Cases

- **Self-hosted resume builder** - keep your CV and personal data on your own server instead of a hosted service.
- **Resume generation by an AI agent** - create and update resumes over the REST API with the API key.
- **Team or career-centre CV tool** - one private instance with the administrator account, with sign-up opened when you want it.
- **Shareable online CV** - publish a resume on a public link and export it to PDF.

## Dependencies for Reactive Resume Hosting

- The reactive-resume service and the postgres service with their volumes, created by the template. A custom domain is optional; the wrapper reads `RAILWAY_PUBLIC_DOMAIN`.

### Deployment Dependencies

- [Reactive Resume repository](https://github.com/AmruthPillai/Reactive-Resume)
- [Reactive Resume documentation](https://docs.rxresu.me)
- [Wrapper image source](https://github.com/bon5co/reactive-resume-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/reactive-resume-or-just-updated-open-sou
