Hosting & Infrastructure 6 min read ·

How to Deploy Python App on Railway: A Complete Guide

We earn commissions when you shop through the links below.

If you’ve been looking for the fastest way to get a Python project live without wrestling with servers, how to deploy Python app on Railway is one of the most Googled questions in the indie hacker and solo developer community right now — and for good reason. Railway takes the pain out of deployment by handling infrastructure automatically, giving you a Git-based workflow that feels natural. In this guide I’ll walk you through the entire process from a blank project to a live URL.

Why Railway for Python?

Railway is purpose-built for developers who want to ship fast. Unlike traditional VPS setups where you configure Nginx, systemd, and firewall rules yourself, Railway detects your runtime, installs dependencies, and starts your process automatically. For Python specifically it supports any WSGI or ASGI app — Flask, FastAPI, Django, you name it. The free tier is generous enough for side projects and the pricing scales cleanly when you grow.

If you’re used to deploying on DigitalOcean droplets, Railway will feel like a significant time saver for apps that don’t need fine-grained server control.

Prerequisites

  • A Railway account (sign up at railway.app — free tier works)
  • Python 3.10+ installed locally
  • A Git repository (GitHub, GitLab, or Bitbucket)
  • A working Python app with a requirements.txt

Step 1 — Prepare Your Python Project

Before you push anything, your project needs three things: a requirements.txt, a Procfile (or a start command), and ideally a runtime.txt to pin your Python version.

Here’s a minimal FastAPI example I’ll use throughout this guide:

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
def root():
    return {"message": "Hello from Railway!"}

@app.get("/health")
def health():
    return {"status": "ok"}

Generate your requirements.txt:

pip freeze > requirements.txt

Or write it manually for a lean setup:

# requirements.txt
fastapi==0.115.0
uvicorn[standard]==0.30.6

Add a Procfile at the project root:

# Procfile
web: uvicorn main:app --host 0.0.0.0 --port $PORT

The $PORT variable is critical. Railway injects this environment variable dynamically — hardcoding a port like 8000 will cause your deployment to fail because Railway routes traffic through its own proxy layer.

Pin your Python version with a runtime.txt:

# runtime.txt
python-3.11.9

Step 2 — Push to GitHub

Railway deploys directly from your Git repository. If your project isn’t on GitHub yet:

git init
git add .
git commit -m "initial commit"
git branch -M main
git remote add origin https://github.com/yourname/your-repo.git
git push -u origin main

Step 3 — Create a New Railway Project

  1. Log in to Railway and click New Project.
  2. Select Deploy from GitHub repo.
  3. Authorize Railway to access your repositories if prompted.
  4. Search for and select your repo.
  5. Railway will immediately start a deployment — you’ll see build logs in real time.

Railway auto-detects Python via your requirements.txt or Pipfile. It installs dependencies using pip, then reads your Procfile to determine the start command. The first build typically takes 60–90 seconds.

Step 4 — Configure Environment Variables

Never hardcode secrets. Railway has a clean Variables UI under your service settings. Click your service → Variables → New Variable.

Common variables you might need:

DATABASE_URL=postgresql://user:pass@host:5432/dbname
SECRET_KEY=your-secret-key-here
DEBUG=false
ALLOWED_HOSTS=yourapp.up.railway.app

You can also import a local .env file using the Railway CLI:

# Install CLI
npm install -g @railway/cli

# Login
railway login

# Import env file
railway vars set --from-file .env

Any variable change triggers an automatic redeploy — no manual restart needed.

Step 5 — Add a Database (Optional)

If your app needs PostgreSQL, Railway makes this trivial. In your project dashboard click New → Database → PostgreSQL. Railway spins up a managed Postgres instance and automatically injects DATABASE_URL into your service’s environment.

In your Python code, read it like any other env variable:

import os
from sqlalchemy import create_engine

DATABASE_URL = os.environ.get("DATABASE_URL")
engine = create_engine(DATABASE_URL)

No connection string copying required — Railway wires the services together automatically.

Step 6 — Generate a Public Domain

Once your deployment shows Active, go to your service → Settings → Networking → Generate Domain. Railway will give you a *.up.railway.app URL immediately. You can also add a custom domain from the same panel and Railway handles SSL automatically.

Debugging Failed Deployments

When something goes wrong, the build logs are your first stop. The most common issues I’ve seen:

  • Missing $PORT — Make sure your server binds to 0.0.0.0:$PORT, not a hardcoded port.
  • No start command — Either add a Procfile or set a start command manually in Service Settings → Deploy → Start Command.
  • Dependency conflicts — Pin versions in requirements.txt to avoid Railway picking incompatible packages.
  • Wrong Python version — Add runtime.txt if Railway is defaulting to a Python version that doesn’t match your local environment.

Using the Railway CLI for Faster Iteration

Once you’ve connected your project locally, the CLI dramatically speeds up your workflow:

# Link local directory to Railway project
railway link

# Tail live logs
railway logs

# Open a shell inside the running container
railway shell

# Trigger a manual deploy
railway up

railway shell is especially useful for running Django migrations or one-off management commands against your production database without leaving the terminal.

Django-Specific Notes

If you’re deploying a Django app, a few extra steps matter. Set your Procfile to use gunicorn:

# Procfile
web: gunicorn myproject.wsgi --bind 0.0.0.0:$PORT

Run migrations as a release command. In Railway you can add a pre-deploy command under Service Settings → Deploy → Pre-Deploy Command:

python manage.py migrate --no-input

Collect static files either as part of your build or using WhiteNoise middleware — Railway doesn’t serve static files natively, so WhiteNoise is the cleanest option for most Django apps.

Final Thoughts

Knowing how to deploy Python app on Railway is a genuinely useful skill that will save you hours compared to traditional VPS setups. The Git-based workflow, automatic dependency detection, built-in database provisioning, and zero SSL configuration make it one of the best platforms for Python developers who want to focus on building rather than DevOps.

If you want to deepen your Python and backend skills alongside this, Udemy has strong Python web development courses that pair well with a deployment workflow like Railway’s.

The next time you finish a project and ask yourself how to deploy Python app on Railway, you’ll have everything you need right here. Push to Git, connect the repo, set your environment variables, and you’re live.