Hey there! We've found the following might help you get unblocked faster:

• 🧵 401 Unauthorized - Monorepo: Frontend/Backend problem

• 📚 Deploying a Monorepo to Railway

• 🧵 How to host monorepo differently

If you find the answer from one of these, please let us know by solving the thread!

Thanks for the links, I had a look through (or had already read the docs) and I don't think that answers the question.

I would try with an had hoc pipeline and it might work most of the times, using railway up -c in theory should wait for the deployment to be done, but I've read in a different thread that -c is broken https://station.railway.com/questions/how-to-wait-deployment-with-health-check-c0b176d9

If -c doesn't work you can expose a route in the backend with the backend version (git commit?) and wait for this route to return the right commit in the pipeline, then once the pipeline is happy with the response then you can continue with the frontend

if you need something more reliable you might probably need to use the railway webhook....

What about something like this little bash script that you can run? The script first deploys the backend, then polls a version or health endpoint to confirm the backend is live with the latest code, and only then triggers the frontend deployment. This ensures that the frontend build can safely use the new backend data, avoiding race conditions and unnecessary delays from arbitrary sleep timers.

/monorepo

├─ /backend

├─ /frontend

├─ /scripts

│ └─ deploy.sh

└─ package.json

In GitHub Actions, Railway pipeline, or other CI, you can add a step:

- name: Deploy Monorepo
  run: ./scripts/deploy.sh

Environment variables:

• Make sure RAILWAY_TOKEN (or your Railway credentials) is set in your shell or CI environment.

• Any service-specific variables (like URLs or commit SHA) can be passed via env vars or Railway secrets.

#!/usr/bin/env bash
set -e

BACKEND_SERVICE="backend"
FRONTEND_SERVICE="frontend"
MAX_ATTEMPTS=30
SLEEP_INTERVAL=5

# 1️⃣ Deploy backend
echo "🚀 Deploying backend..."
railway up --service $BACKEND_SERVICE

# 2️⃣ Wait for backend to be ready
echo "⏳ Waiting for backend to be ready..."
ATTEMPT=0
while true; do
  ATTEMPT=$((ATTEMPT+1))
  
  # Replace with your actual endpoint
  RESPONSE=$(curl -s http://backend.up.railway.app/version)
  COMMIT=$(echo $RESPONSE | jq -r '.commit')

  if [[ "$COMMIT" == "$(git rev-parse HEAD)" ]]; then
    echo "✅ Backend is live with the correct version!"
    break
  fi

  if [[ $ATTEMPT -ge $MAX_ATTEMPTS ]]; then
    echo "❌ Backend did not become ready in time."
    exit 1
  fi

  sleep $SLEEP_INTERVAL
done

# 3️⃣ Deploy frontend
echo "🚀 Deploying frontend..."
railway up --service $FRONTEND_SERVICE

Thanks for the useful thoughts, I am going to work with that now and will get back to you.

railway up -c is working perfectly for me - ie, it does not return until the deployment is complete. So I can use it to arrange sequential deploys from a github workflow, as you suggested:

name: Sequential Deploy to Railway

on:
    push:
        branches:
            - main

jobs:
    deploy:
        runs-on: ubuntu-latest
        container: ghcr.io/railwayapp/cli:latest
        env:
            RAILWAY_TOKEN: ${{ secrets.RAILWAY_TOKEN }}

        steps:
            - name: Checkout code
              uses: actions/checkout@v4

            - name: Deploy Backend to Railway and wait using -c
              run: railway up -c --environment=production --service=backend

            - name: Deploy Frontend to Railway
              run: railway up --environment=production --service=frontend

The Bash script idea is of course useful if you don't have GitHub actions to hand, but for anyone reading this in future, it looks like something as simple as this would work. I gave it a quick test and it seemed OK to me:

#!/usr/bin/env bash

railway up -c --environment production --service backend
railway up --environment production --service frontend

I will leave a comment on the thread you linked to above saying that -c seems to do the job.

If, however, anyone in future runs into the issue where -c does not seem to block for you then @robksawyer's bash script looks very useful.