Learn how to deploy with Runles

Runles is a modern deployment platform that makes it easy to deploy, manage, and scale your applications. Connect your Git repository, and we handle the rest — building, deploying, and keeping your apps running smoothly.

Get your application live in just a few steps. No complex configuration required.

✓ GitHub (public & private repos)
✓ GitLab (public & private repos)
✓ Manual Git URL

DATABASE_URL=postgresql://user:pass@host:5432/db
NODE_ENV=production
API_KEY=your_secret_key

GitHub

Connect your GitHub account to access your repositories. We support both public and private repositories.

1. Go to Projects → New Project
2. Click Connect GitHub
3. Authorize Runles to access your repositories
4. Select the repository you want to deploy

GitLab

Works with GitLab.com and self-hosted GitLab instances.

1. Go to Projects → New Project
2. Click Connect GitLab
3. Authorize Runles to access your repositories
4. Select the repository you want to deploy

Automatic Deployments

Every push to your configured branch triggers an automatic deployment. The build process:

Manual Deployments

You can also trigger deployments manually from the dashboard:

• Go to your project
• Click Deploy button
• Optionally select Clear Build Cache for a fresh build

Rollbacks

If something goes wrong, you can instantly rollback to a previous deployment:

1. Go to Project → Deployments
2. Find a previous successful deployment
3. Click "Rollback to this version"
4. Your app instantly reverts to that state

Runles provides fully managed PostgreSQL databases with automatic backups, SSL connections, and easy scaling.

Creating a Database

1. Go to Databases → Create Database
2. Enter a name for your database
3. Select your plan (Basic, Standard, or Pro)
4. Click Create

Connection Details

Once created, you'll receive connection details:

DATABASE_URL=postgresql://username:password@your-db.runles.com:5432/dbname

# Or individual values:
DB_HOST=your-db.runles.com
DB_PORT=5432
DB_USER=username
DB_PASSWORD=your_secure_password
DB_NAME=dbname

Database Migration

You can migrate an existing database to Runles:

1. Go to Databases → Migrate Database
2. Enter your source database connection details
3. Select the PostgreSQL version
4. Click Start Migration

Environment variables let you configure your application without changing code. Store API keys, database URLs, and other settings securely.

How It Works

Runles reads environment variables from two sources:

1. .env file in your repository (automatically loaded)
2. Dashboard variables (override .env values)

# These are automatically loaded during deployment
NODE_ENV=production
PORT=3000
DATABASE_URL=postgresql://...
REDIS_URL=redis://...
API_SECRET=your_secret_here

Adding Variables in Dashboard

To add or override environment variables:

1. Go to your Project → Environment Variables
2. Click Add Variable
3. Enter the key and value
4. Select the branch (variables can be branch-specific)
5. Your app will automatically redeploy with the new variables

Every app gets a free *.runles.com subdomain. You can also add your own custom domain with automatic SSL.

Adding a Custom Domain

1. Go to your Project → Settings → Domains
2. Enter your domain (e.g., api.yourcompany.com)
3. Add the DNS records shown to your domain provider
4. Wait for DNS propagation (usually 5-30 minutes)
5. SSL certificate is automatically provisioned

DNS Configuration

# For root domain (yourcompany.com)
Type: A
Name: @
Value: [Your Runles IP]

# For subdomain (api.yourcompany.com)
Type: CNAME
Name: api
Value: your-app.runles.com

Runles automatically detects your project type and builds it appropriately. You can also provide your own Dockerfile for full control.

Auto-Detection

Runles automatically detects and builds:

Custom Dockerfile

For full control, add a Dockerfile to your repository root:

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm ci --production
COPY . .
EXPOSE 3000
CMD ["npm", "start"]

Create organizations to manage projects and team members together. Share resources, manage billing, and control access.

Roles

Inviting Members

1. Go to Organization → Team
2. Click Invite Member
3. Enter their email and select a role
4. They'll receive an invitation email

Runles integrates with your Git workflow to automatically deploy on every push.

Git Webhooks

When you create a project, Runles automatically sets up webhooks. Every push to your configured branch triggers:

• Automatic code pull
• Build process
• Container deployment
• DNS/SSL configuration
• Email notifications (if enabled)

Preview Environments

Enable preview environments to get a unique URL for each pull request:

Pull Request #123 → pr-123.preview.runles.com

• Auto-created when PR is opened
• Auto-deleted when PR is merged/closed
• URL is commented on the PR

Security is built into every layer of Runles.

Runles automatically detects Node.js projects and configures the build process.

Requirements

• A package.json file
• A start script in package.json
• Your app should listen on the PORT environment variable

{
  "name": "my-app",
  "scripts": {
    "start": "node server.js",
    "build": "npm run compile"
  },
  "engines": {
    "node": "18"
  }
}

Express Example

const express = require('express');
const app = express();

// Use PORT from environment (Runles sets this)
const PORT = process.env.PORT || 3000;

app.get('/', (req, res) => {
  res.send('Hello from Runles!');
});

app.listen(PORT, () => {
  console.log(`Server running on port ${PORT}`);
});

Python applications are detected by the presence of requirements.txt.

Requirements

flask==2.3.0
gunicorn==21.0.0
python-dotenv==1.0.0

Flask Example

from flask import Flask
import os

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello from Runles!'

if __name__ == '__main__':
    port = int(os.environ.get('PORT', 5000))
    app.run(host='0.0.0.0', port=port)

Follow these best practices to create efficient, secure Docker images.

Multi-Stage Builds

Use multi-stage builds to reduce image size:

# Build stage
FROM node:18-alpine AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build

# Production stage
FROM node:18-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

Tips

• Use alpine base images for smaller size
• Add a .dockerignore file to exclude unnecessary files
• Use npm ci instead of npm install for reproducible builds
• Don't run as root — use a non-root user
• Set NODE_ENV=production for Node.js apps