home / skills / hoodini / ai-agents-skills / railway

railway skill

/skills/railway

This skill helps you deploy and manage applications on Railway, including databases, private networking, and multi-service setups.

npx playbooks add skill hoodini/ai-agents-skills --skill railway

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.1 KB
---
name: railway
description: Deploy applications on Railway platform. Use when deploying containerized apps, setting up databases, configuring private networking, or managing Railway projects. Triggers on Railway, railway.app, deploy container, Railway database.
---

# Railway Deployment

Deploy and manage applications on Railway's platform.

## Quick Start

```bash
# Install Railway CLI
npm i -g @railway/cli

# Login
railway login

# Initialize project
railway init

# Deploy
railway up
```

## railway.toml Configuration

```toml
[build]
builder = "nixpacks"
buildCommand = "npm run build"

[deploy]
startCommand = "npm start"
healthcheckPath = "/health"
healthcheckTimeout = 300
restartPolicyType = "on_failure"
restartPolicyMaxRetries = 3

[service]
internalPort = 3000
```

## Nixpacks Configuration

```toml
# nixpacks.toml
[phases.setup]
nixPkgs = ["nodejs-18_x", "python311"]

[phases.install]
cmds = ["npm ci"]

[phases.build]
cmds = ["npm run build"]

[start]
cmd = "npm start"
```

## Environment Variables

```bash
# Set variable
railway variables set DATABASE_URL="postgres://..."

# Set from file
railway variables set < .env

# Link to service
railway service
railway variables set API_KEY="secret"
```

## Database Services

### PostgreSQL
```bash
# Add PostgreSQL
railway add -d postgres

# Get connection string
railway variables get DATABASE_URL
```

### Redis
```bash
railway add -d redis
# Access via REDIS_URL
```

### MySQL
```bash
railway add -d mysql
# Access via MYSQL_URL
```

## Private Networking

```yaml
# Services can communicate via internal DNS
# Format: ${{service-name}}.railway.internal

# Example: API calling database service
DATABASE_HOST: ${{postgres.railway.internal}}
DATABASE_PORT: 5432
```

## Volumes (Persistent Storage)

```bash
# Create volume
railway volume create my-data

# Mount in service
railway volume attach my-data:/app/data
```

In code:
```javascript
// Data persists across deploys
const dataPath = '/app/data';
fs.writeFileSync(`${dataPath}/file.json`, JSON.stringify(data));
```

## Cron Jobs

```toml
# railway.toml
[deploy]
startCommand = "node cron.js"
cronSchedule = "0 */6 * * *"  # Every 6 hours
```

## Multi-Service Setup

```
my-project/
├── api/
│   ├── railway.toml
│   └── ...
├── worker/
│   ├── railway.toml
│   └── ...
└── frontend/
    ├── railway.toml
    └── ...
```

Deploy each:
```bash
cd api && railway up
cd ../worker && railway up
cd ../frontend && railway up
```

## Dockerfile Deploy

```dockerfile
FROM node:18-alpine

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production
COPY . .

EXPOSE 3000
CMD ["npm", "start"]
```

```toml
# railway.toml
[build]
builder = "dockerfile"
dockerfilePath = "./Dockerfile"
```

## Health Checks

```typescript
// Express health endpoint
app.get('/health', (req, res) => {
  res.status(200).json({ 
    status: 'healthy',
    timestamp: new Date().toISOString()
  });
});
```

```toml
# railway.toml
[deploy]
healthcheckPath = "/health"
healthcheckTimeout = 100
```

## Resources

- **Railway Docs**: https://docs.railway.app
- **Railway CLI**: https://docs.railway.app/develop/cli

Overview

This skill deploys and manages applications on the Railway platform. It guides CLI-based workflows, project configuration, and service management for containerized apps, databases, volumes, cron jobs, and private networking. Use it to automate deployments, link services, and keep production services healthy and persistent.

How this skill works

The skill uses Railway CLI commands and railway.toml configuration to build and deploy services. It configures builders (nixpacks or Dockerfile), manages environment variables and database services, attaches volumes for persistent storage, and sets up private DNS for internal service communication. It also supports health checks, cron schedules, and multi-service project workflows.

When to use it

  • Deploy a new containerized or Node app to Railway quickly using railway up
  • Provision and connect managed databases (Postgres, Redis, MySQL) for your app
  • Set up private networking so services communicate securely via internal DNS
  • Attach persistent volumes to retain state or uploaded files across deploys
  • Run periodic tasks with cron schedules or deploy background workers separately

Best practices

  • Use railway.toml to declare build, start, and healthcheck settings for reproducible deploys
  • Keep secrets out of source by storing them with railway variables and loading from .env when needed
  • Prefer healthcheck endpoints so Railway can monitor and restart unhealthy services
  • Use Nixpacks for zero-configuration builds or Dockerfile when you need full control
  • Organize multi-service projects into separate service folders and deploy them independently

Example use cases

  • Deploy a Node/Express API with a Postgres database and attach DATABASE_URL from Railway variables
  • Run a worker service for background jobs and a separate frontend service; deploy each folder with railway up
  • Bind a persistent volume to store user uploads at /app/data so files survive redeploys
  • Deploy with a Dockerfile when you require custom OS packages or a specific runtime
  • Configure an internal DNS host like postgres.railway.internal for secure DB connections between services

FAQ

How do I set environment variables?

Use railway variables set KEY="value" or pipe a .env file with railway variables set < .env. Retrieve values with railway variables get KEY.

Can I use Dockerfile builds?

Yes. Set builder = "dockerfile" and specify dockerfilePath in railway.toml, or let Nixpacks auto-detect for simpler setups.

How do services communicate privately?

Services use internal DNS in the format service-name.railway.internal and standard ports; configure DATABASE_HOST and DATABASE_PORT accordingly.