Deploy Rallly | (Just Updated) Doodle Alternative, Meeting Polls, Admin Login Pre-Created, Sign-up Closed

Rallly meeting poll scheduler, Doodle alternative, share dates, get votes

Deploy Rallly | (Just Updated) Doodle Alternative, Meeting Polls, Admin Login Pre-Created, Sign-up Closed

database

postgres:17

Just deployed

/var/lib/postgresql

Just deployed

Deploy and Host Rallly on Railway

Built for an LLM agent to deploy and use. The deploy form has no fields to fill: the administrator login and the database credentials are generated, the administrator is created at boot with a password you can sign in with (the stock image only offers an emailed one-time code, which needs SMTP), and public registration is closed, so a stranger who finds the domain cannot create an account. Rallly is an open-source meeting scheduling tool: propose dates, share one link, collect votes and find the time that works for everyone, an alternative to Doodle.

About Hosting Rallly

This template runs two services: rallly, the official lukevella/rallly image (4.17.1) pinned by digest through a thin wrapper, and database, a PostgreSQL 17 instance with a volume at /var/lib/postgresql that holds every poll, vote and user. One public domain serves the web app and its API. The healthcheck is GET /api/status. The app keeps nothing on disk, so it has no volume of its own.

What the wrapper fixes. The stock image expects a ready-made DATABASE_URL, needs its migrations run before the server starts, signs people in only with an emailed one-time code or a social provider, and allows open registration. The wrapper builds the connection string and the public URL from plain Railway variables, binds the server to Railway's injected PORT, runs the migrations, creates one verified administrator from RALLLY_ADMIN_EMAIL and RALLLY_ADMIN_PASSWORD, and sets REGISTRATION_ENABLED=false. The administrator is created only when no user with that address exists and the password is stored in the database, so a redeploy never overwrites a password you changed.

Using it. Open the domain, sign in with RALLLY_ADMIN_EMAIL and RALLLY_ADMIN_PASSWORD, and finish the one-time space setup page that Rallly shows after the first login. Polls can be created and shared by link. Email and file storage are optional: without SMTP no notification mail is sent, and without S3 avatars and attachments are off; add the upstream SMTP_* or S3_* variables to the rallly service to turn them on. The REST API of Rallly needs a paid plan upstream, so an agent drives the same session API the web app uses.

Agent contract

  • Public URL: https://RAILWAY_PUBLIC_DOMAIN (the generated domain of the rallly service)
  • Private URL: http://rallly.railway.internal:8080
  • Credentials: the variables RALLLY_ADMIN_EMAIL and RALLLY_ADMIN_PASSWORD on the rallly service (plain text)
  • Auth: POST /api/better-auth/sign-in/email with JSON {"email","password"} and an origin header equal to the public URL sets a session cookie; send the cookie jar on every later call to /api/better-auth/*
  • Health: GET /api/status returns 200 without credentials
#!/bin/sh
# needs: RAILWAY_PUBLIC_DOMAIN, RALLLY_ADMIN_EMAIL, RALLLY_ADMIN_PASSWORD (variables of the rallly service); also curl, jq.
R="https://$RAILWAY_PUBLIC_DOMAIN"; J="content-type: application/json"; O="origin: $R"; A="$R/api/better-auth"; JAR=$(mktemp)
n=0; until [ "$(curl -s -o /dev/null -w '%{http_code}' "$R/api/status")" = 200 ]; do n=$((n+1)); [ "$n" -le 90 ] || break; sleep 5; done
curl -s -o /dev/null -w "health: %{http_code}\n" "$R/api/status"
# signup: none - registration is switched off (REGISTRATION_ENABLED=false): the attempt below is refused with 400 EMAIL_PASSWORD_SIGN_UP_DISABLED, and an emailed-code sign-in for an unknown address answers 400 SIGNUP_DISABLED instead of creating the account
curl -s -o /dev/null -w "public signup: %{http_code}\n" -H "$J" -H "$O" -d '{"email":"stranger@example.com","password":"a-stranger-twelve","name":"x"}' "$A/sign-up/email"
# sign in with the generated login: the cookie set here authenticates every call after this
curl -s -o /dev/null -w "login: %{http_code}\n" -c "$JAR" -H "$J" -H "$O" -d "$(jq -nc --arg e "$RALLLY_ADMIN_EMAIL" --arg p "$RALLLY_ADMIN_PASSWORD" '{email:$e,password:$p}')" "$A/sign-in/email"
echo "read with session: $(curl -s -b "$JAR" "$A/get-session" | jq -r '.user.email')"
echo "read without session: $(curl -s "$A/get-session")"
# write-auth: update-user renames the signed-in user; without the session cookie it answers 401
curl -s -o /dev/null -w "write with session: %{http_code}\n" -b "$JAR" -H "$J" -H "$O" -d '{"name":"Agent"}' "$A/update-user"
curl -s -o /dev/null -w "write without key: %{http_code}\n" -H "$J" -H "$O" -d '{"name":"Agent"}' "$A/update-user"

Expected output against a fresh deploy:

health: 200
public signup: 400
login: 200
read with session: admin@RAILWAY_PUBLIC_DOMAIN
read without session: null
write with session: 200
write without key: 401

The refusals are the contract: a request without a session is refused (write without key: 401), and registration is closed (the sign-up attempt is answered 400 with EMAIL_PASSWORD_SIGN_UP_DISABLED, and an emailed-code sign-in for an unknown address answers SIGNUP_DISABLED instead of creating the account).

Why Deploy Rallly 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 Rallly 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 server is healthy, registration is closed, and the generated login can read and write.
  • Sign-in works without SMTP - the administrator signs in with a generated password instead of an emailed code.
  • Registration closed - nobody else can create an account.
  • Data survives redeploys - polls and votes live in PostgreSQL on a volume.
  • Pinned - the upstream image is pinned by digest and the wrapper by tag and digest.

Common Use Cases

  • Team scheduling - propose a few time slots, share one link and see who can attend, instead of a Doodle subscription.
  • Self-hosted polls for clients - keep invitee names and email addresses on your own server.
  • Scheduling for AI agents - create and read polls with a generated login.

Dependencies for Rallly Hosting

  • The rallly service and a PostgreSQL service with its volume, created by the template.

Deployment Dependencies


Template Content

More templates in this category

View Template
Rocky Linux
Hosted Rocky Linux 9 workspace with SSH and persistent storage. 🚀

codestorm
51
View Template
Foundry Virtual Tabletop
Self-hosted virtual tabletop for role-playing games (license required)

Lucas
71
View Template
NEW
Double Commander in your browser
The Double Commander file manager in the cloud, from any device

Nermin Sabanovic
0