### npm start Execution Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/log-analysis.md

Example output from running 'npm start' to initiate the application. Check for server startup messages and port binding.

```bash
==> Running 'npm start'\n> app@1.0.0 start\n> node server.js\n\nServer listening on port 10000
```

--------------------------------

### Common Node.js Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Examples of how to start a Node.js application. These can be direct file execution or using scripts defined in package.json.

```bash
npm start
```

```bash
node server.js
```

```bash
node dist/main.js
```

--------------------------------

### Get Asynq module

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

Install the Asynq Go module using `go get`.

```bash
go get github.com/hibiken/asynq
```

--------------------------------

### Common Python Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Examples of start commands for various Python web frameworks and task queues. Ensure the command binds to 0.0.0.0 and the specified port ($PORT).

```bash
gunicorn app:app
```

```bash
gunicorn config.wsgi:application
```

```bash
uvicorn main:app --host 0.0.0.0 --port $PORT
```

```bash
celery -A tasks worker
```

--------------------------------

### Common Ruby Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Examples of start commands for Ruby applications using different frameworks like Rails, Puma, and Rackup. Also includes a command for starting Sidekiq workers.

```bash
bundle exec rails server -b 0.0.0.0 -p $PORT
```

```bash
bundle exec puma -C config/puma.rb
```

```bash
bundle exec rackup -o 0.0.0.0 -p $PORT
```

```bash
bundle exec sidekiq
```

--------------------------------

### Go Example Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

A sample Render configuration for a Go web service, specifying the runtime, build command, and start command.

```yaml
type: web
name: go-app
runtime: go
buildCommand: go build -o bin/app .
startCommand: ./bin/app
```

--------------------------------

### Node.js Procfile Examples

Source: https://github.com/render-oss/skills/blob/main/skills/render-migrate-from-heroku/references/buildpack-mapping.md

Common Procfile patterns for Node.js applications. These examples show different ways to start a web process or a worker process.

```shell
web: npm start
web: node server.js
web: next start -p $PORT
worker: node worker.js
```

--------------------------------

### Node.js Example Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

A sample Render configuration for a Node.js web service, specifying the runtime, build command, and start command.

```yaml
type: web
name: node-app
runtime: node
buildCommand: npm ci && npm run build
startCommand: npm start
```

--------------------------------

### Rust Example Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

A sample Render configuration for a Rust web service, specifying the runtime, build command, and start command.

```yaml
type: web
name: rust-app
runtime: rust
buildCommand: cargo build --release
startCommand: ./target/release/myapp
```

--------------------------------

### Ruby Example Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

A sample Render configuration for a Ruby on Rails application, specifying the runtime, build command, and start command.

```yaml
type: web
name: rails-app
runtime: ruby
buildCommand: bundle install && bundle exec rails assets:precompile
startCommand: bundle exec puma -C config/puma.rb
```

--------------------------------

### Example Dockerfile for Node.js Application

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/error-patterns.md

A sample Dockerfile demonstrating best practices for building a Node.js application, including setting a working directory, copying files, installing dependencies, building the app, and defining runtime commands.

```dockerfile
# Use valid base image
FROM node:20-alpine

# Set working directory
WORKDIR /app

# Copy dependency files first
COPY package*.json .
RUN npm ci

# Then copy source
COPY . .

# Build
RUN npm run build

# Expose port
EXPOSE 10000

# Start
CMD ["npm", "start"]
```

--------------------------------

### Python Example Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

A sample Render configuration for a Python web service, specifying the runtime, build command, and start command for a Flask application.

```yaml
type: web
name: python-app
runtime: python
buildCommand: pip install -r requirements.txt
startCommand: gunicorn app:app --bind 0.0.0.0:$PORT
```

--------------------------------

### Elixir Application Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Example configuration for an Elixir web application, specifying build and start commands.

```yaml
type: web
name: elixir-app
runtime: elixir
buildCommand: mix deps.get --only prod && mix compile
startCommand: mix phx.server
```

--------------------------------

### Python Build and Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/SKILL.md

Commands for building and starting a Python workflow service on Render.

```text
pip install -r requirements.txt
```

```text
python main.py
```

--------------------------------

### Node.js Build Script Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/error-patterns.md

Example of a build script configuration in a Node.js package.json file.

```json
{
  "scripts": {
    "build": "tsc",  // or webpack, vite, etc.
    "start": "node dist/index.js"
  }
}
```

--------------------------------

### Multi-stage Dockerfile Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

An example of a multi-stage Dockerfile for building an application, optimizing for smaller production image sizes.

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

# Production stage
FROM node:20-alpine
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY package*.json ./
RUN npm ci --only=production
EXPOSE 10000
CMD ["node", "dist/main.js"]
```

--------------------------------

### Combined Service Wiring Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-blueprints/references/wiring-patterns.md

A comprehensive example demonstrating wiring a web service to a database, key-value store, private service, generating a secret, using manual input, and including environment group variables.

```yaml
services:
  - type: web
    name: api
    runtime: node
    plan: starter
    buildCommand: npm ci
    startCommand: npm start
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: db
          property: connectionString
      - key: REDIS_URL
        fromService:
          name: cache
          type: keyvalue
          property: connectionString
      - key: AUTH_HOST
        fromService:
          name: auth
          type: pserv
          property: hostport
      - key: JWT_SECRET
        generateValue: true
      - key: STRIPE_KEY
        sync: false
      - fromGroup: shared-config

  - type: pserv
    name: auth
    runtime: node
    plan: starter
    buildCommand: npm ci
    startCommand: npm start

  - type: keyvalue
    name: cache
    plan: starter
    maxmemoryPolicy: allkeys-lru
    ipAllowList:
      - source: 0.0.0.0/0
        description: everywhere

databases:
  - name: db
    plan: starter

envVarGroups:
  - name: shared-config
    envVars:
      - key: LOG_LEVEL
        value: info
```

--------------------------------

### Port Binding: Go Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Example of binding a Go application to the correct port and host.

```go
port := os.Getenv("PORT")
if port == "" {
    port = "3000"
}
http.ListenAndServe(":
```

--------------------------------

### Install Render CLI on Linux/macOS

Source: https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md

Use this command to install the Render CLI on Linux or macOS by downloading and executing an installation script.

```bash
curl -fsSL https://raw.githubusercontent.com/render-oss/cli/refs/heads/main/bin/install.sh | sh
```

--------------------------------

### Configure Node.js Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/troubleshooting.md

Example build command for Node.js projects using npm ci for faster dependency installation.

```yaml
# Node.js
buildCommand: npm ci && npm run build
```

--------------------------------

### Python Build Command Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/error-patterns.md

Example of setting the build command in render.yaml for Python projects, focusing on dependency installation.

```yaml
buildCommand: pip install -r requirements.txt
```

--------------------------------

### Web Service Definition in render.yaml

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

Example of a web service configuration, including name, runtime, plan, build and start commands, branch, auto-deploy settings, and environment variables.

```yaml
services:
  - type: web
    name: api-server
    runtime: node
    plan: free
    buildCommand: npm ci
    startCommand: npm start
    branch: main
    autoDeploy: true
    envVars:
      - key: NODE_ENV
        value: production
      - key: PORT
        value: 10000
```

--------------------------------

### Install BullMQ and ioredis

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

Install the necessary Node.js packages for BullMQ.

```bash
npm install bullmq ioredis
```

--------------------------------

### TypeScript Build and Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/SKILL.md

Commands for building and starting a TypeScript workflow service on Render.

```text
npm install && npm run build
```

```text
node dist/main.js
```

--------------------------------

### Install Render Skills

Source: https://github.com/render-oss/skills/blob/main/README.md

Use this command to install Render skills into your AI tool. Ensure you have the Render CLI installed.

```bash
render skills install
```

--------------------------------

### Build Commands: bun

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `bun install --frozen-lockfile` for non-interactive dependency installation.

```shell
bun install --frozen-lockfile
```

--------------------------------

### npm ci Build Command Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/log-analysis.md

Example output from running 'npm ci' during the build phase. Look for npm errors or compilation issues.

```bash
==> Running 'npm ci'\nnpm WARN deprecated package@1.0.0\nadded 250 packages in 15s
```

--------------------------------

### Build Commands: uv

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `uv sync` for non-interactive dependency installation.

```shell
uv sync
```

--------------------------------

### Example Agent Prompts for Render CLI

Source: https://github.com/render-oss/skills/blob/main/README.md

These are example prompts you can use to interact with your agent for various Render operations. They cover deployment, debugging, monitoring, and configuration tasks.

```text
Deploy my application to Render.
```

```text
Debug why my Render service won't start.
```

```text
Is my Render service healthy?
```

```text
Set up a private service for this internal API.
```

```text
Add a cron job that runs every night.
```

```text
Configure custom domains for this web service.
```

```text
Migrate my Heroku app to Render.
```

--------------------------------

### Install Render CLI with Homebrew

Source: https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md

Use this command to install the Render CLI using Homebrew on macOS or Linux.

```bash
brew update && brew install render
```

--------------------------------

### Verify Render CLI Installation and Authentication

Source: https://github.com/render-oss/skills/blob/main/skills/render-migrate-from-heroku/references/data-migration.md

Confirm that the Render CLI is installed and authenticated. If not installed, instructions are provided for macOS and Linux/macOS. Authentication is done via `render login`.

```bash
render --version
render whoami
```

--------------------------------

### apt Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/configuration-guide.md

Use 'apt-get update && apt-get install -y' for system package installation, including the '-y' flag for auto-confirmation.

```yaml
buildCommand: apt-get update && apt-get install -y libpq-dev
# Use -y flag to auto-confirm
```

--------------------------------

### Install Celery with Redis support

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

Install the Celery library with the Redis transport.

```bash
pip install "celery[redis]"
```

--------------------------------

### Elixir Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Common commands to start Elixir applications, including the Phoenix server.

```bash
mix phx.server
```

```bash
elixir --name myapp -S mix phx.server
```

--------------------------------

### Port Binding: Python Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Example of binding a Python application to the correct port and host.

```python
import os

port = int(os.environ.get('PORT', 5000))
app.run(host='0.0.0.0', port=port)
```

--------------------------------

### Instance Type: Starter

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/quick-reference.md

The 'starter' instance type provides 0.5 CPU and 512 MB of RAM.

```text
starter
0.5 CPU / 512 MB
```

--------------------------------

### Bundler Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/configuration-guide.md

Use 'bundle install' with '--jobs' and '--retry' flags for efficient Ruby gem installation.

```yaml
buildCommand: bundle install --jobs=4 --retry=3
```

--------------------------------

### Python Procfile Examples

Source: https://github.com/render-oss/skills/blob/main/skills/render-migrate-from-heroku/references/buildpack-mapping.md

Common Procfile patterns for Python applications. Includes examples for web services using Gunicorn and Uvicorn, worker processes with Celery, and release phase commands.

```shell
web: gunicorn app:app
web: gunicorn myproject.wsgi --log-file -
web: uvicorn main:app --host 0.0.0.0 --port $PORT
worker: celery -A myproject worker
clock: celery -A myproject beat
release: python manage.py migrate
```

--------------------------------

### Successful Deployment Log

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/log-analysis.md

Example of a log output indicating a successful deployment.

```text
==> Cloning from https://github.com/user/repo...
==> Running build command 'npm ci'
added 250 packages in 15s
==> Running start command 'npm start'
Server listening on port 10000
==> Health check passed
Deploy succeeded
```

--------------------------------

### Common Go Start Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Simple commands to execute your compiled Go application. Assumes the binary is placed in the 'bin' directory.

```bash
./bin/app
```

```bash
./bin/server
```

--------------------------------

### Install Render Skills via npm

Source: https://github.com/render-oss/skills/blob/main/README.md

Alternative installation method using npx to add Render skills. This is useful if you prefer using npm-based tools.

```bash
npx skills add render-oss/skills
```

--------------------------------

### Port Binding: Node.js Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Example of binding a Node.js application to the correct port and host.

```javascript
const PORT = process.env.PORT || 3000;
app.listen(PORT, '0.0.0.0', () => {
  console.log(`Server running on port ${PORT}`);
});
```

--------------------------------

### Build Commands: bundler

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `bundle install --jobs=4 --retry=3` for non-interactive dependency installation.

```shell
bundle install --jobs=4 --retry=3
```

--------------------------------

### Minimal Asynq worker

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

A simplified Asynq worker setup that parses the Redis URI and starts the server.

```go
package main

import (
    "log"
    "os"

    "github.com/hibiken/asynq"
)

func main() {
    redisOpt, err := asynq.ParseRedisURI(os.Getenv("REDIS_URL"))
    if err != nil {
        log.Fatal(err)
    }
    srv := asynq.NewServer(redisOpt, asynq.Config{Concurrency: 10})
    mux := asynq.NewServeMux()
    // mux.HandleFunc("task:type", handler)
    if err := srv.Run(mux); err != nil {
        log.Fatal(err)
    }
}
```

--------------------------------

### Ruby Cron Job Blueprint Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-cron-jobs/references/migration-from-scheduler.md

An example of a Render Blueprint configuration for a Ruby cron job, migrated from Heroku Scheduler. It includes service definition, schedule, build and start commands, and environment variables.

```yaml
services:
  - type: cron
    name: daily-cleanup
    runtime: ruby
    plan: starter
    schedule: "0 0 * * *"
    buildCommand: bundle install
    startCommand: bundle exec rake db:cleanup
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: my-db
          property: connectionString
      - key: RAILS_ENV
        value: production

databases:
  - name: my-db
    plan: starter
```

--------------------------------

### Configure Python Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/troubleshooting.md

Example build command for Python projects using pip to install requirements.

```yaml
# Python
buildCommand: pip install -r requirements.txt
```

--------------------------------

### Install and Deploy with Render CLI in GitHub Actions

Source: https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md

This snippet shows how to install a specific version of the Render CLI and deploy a service using GitHub Actions. It emphasizes pinning the CLI version for stability and using environment variables for sensitive information.

```yaml
name: Deploy to Render
on:
  push:
    branches: [main]
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Install Render CLI
        run: |
          curl -L https://github.com/render-oss/cli/releases/download/v1.1.0/cli_1.1.0_linux_amd64.zip -o render.zip
          unzip render.zip
          sudo mv cli_v1.1.0 /usr/local/bin/render
      - name: Deploy
        env:
          RENDER_API_KEY: ${{ secrets.RENDER_API_KEY }}
        run: render deploys create ${{ secrets.RENDER_SERVICE_ID }} --wait --confirm -o json
```

--------------------------------

### Go Connection with go-redis

Source: https://github.com/render-oss/skills/blob/main/skills/render-keyvalue/references/connection-examples.md

Connect to Redis using the go-redis library in Go. This example demonstrates setting and getting a key.

```go
package main

import (
    "context"
    "fmt"
    "os"
    "github.com/redis/go-redis/v9"
)

func main() {
    opt, _ := redis.ParseURL(os.Getenv("REDIS_URL"))
    client := redis.NewClient(opt)
    ctx := context.Background()

    client.Set(ctx, "key", "value", 0)
    val, _ := client.Get(ctx, "key").Result()
    fmt.Println(val)
}
```

--------------------------------

### Node.js Build with Build Step

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/configuration-guide.md

Combine dependency installation with a build script for Node.js applications.

```yaml
buildCommand: npm ci && npm run build
```

--------------------------------

### Python Connection with redis-py

Source: https://github.com/render-oss/skills/blob/main/skills/render-keyvalue/references/connection-examples.md

Connect to Redis using the redis-py library in Python. This example demonstrates setting and getting a key.

```python
import os
import redis

r = redis.from_url(os.environ['REDIS_URL'])

r.set('key', 'value')
print(r.get('key').decode())
```

--------------------------------

### Create a Static Site

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/direct-creation.md

Use this to create a new static site. Specify repository, build commands, publish path, and environment variables.

```python
create_static_site(
  name: "my-frontend",
  repo: "https://github.com/username/repo",
  branch: "main",
  buildCommand: "npm run build",
  publishPath: "dist",  # or build, public, out
  envVars: [
    {"key": "VITE_API_URL", "value": "https://api.example.com"}
  ]
)
```

--------------------------------

### Node.js Connection with ioredis

Source: https://github.com/render-oss/skills/blob/main/skills/render-keyvalue/references/connection-examples.md

Connect to Redis using the ioredis library in Node.js. This example demonstrates setting and getting a key-value pair.

```javascript
import Redis from 'ioredis'

const redis = new Redis(process.env.REDIS_URL)

await redis.set('key', 'value')
const result = await redis.get('key')
console.log(result)
```

--------------------------------

### Verify Database Service Provisioning

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/troubleshooting.md

Use the 'render services' command to ensure your database service has been successfully provisioned and is available.

```bash
render services -o json
# Look for database service
```

--------------------------------

### Configure Go Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/troubleshooting.md

Example build command for Go projects, specifying the output binary name.

```yaml
# Go
buildCommand: go build -o bin/app .
```

--------------------------------

### Manage Render Skills

Source: https://github.com/render-oss/skills/blob/main/README.md

These commands provide interactive management and listing of installed Render skills. Use 'update' to get the latest versions.

```bash
render skills
```

```bash
render skills list
```

```bash
render skills update
```

--------------------------------

### Pre-built Private Image Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Configuration example for deploying a pre-built private Docker image, including registry credentials.

```yaml
type: web
name: private-app
runtime: image
image: myregistry.com/myapp:latest
registryCredential:
  username: my-username
  password:
    sync: false  # User provides in Dashboard
```

--------------------------------

### Run Task Asynchronously with Render SDK (TypeScript)

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/SKILL.md

Use this snippet to start a workflow task asynchronously and retrieve its results. Ensure the Render SDK is installed.

```typescript
import { Render } from "@renderinc/sdk";

const render = new Render();
const started = await render.workflows.startTask("my-workflow/hello", ["world"]);
const finished = await started.get();
console.log(finished.results);
```

--------------------------------

### Get HTTP Latency Metrics

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/metrics-debugging.md

Retrieve HTTP latency metrics for a given resource. Specify the desired quantile (e.g., 0.95 for p95) and start time.

```text
get_metrics(
  resourceId: "<service-id>",
  metricTypes: ["http_latency"],
  httpLatencyQuantile: 0.95,
  startTime: "<1-hour-ago-ISO8601>"
)
```

--------------------------------

### Instance Type: Standard

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/quick-reference.md

The 'standard' instance type, which is the default, provides 1 CPU and 2 GB of RAM.

```text
standard (default)
1 CPU / 2 GB
```

--------------------------------

### Referencing a Private Service in Blueprints

Source: https://github.com/render-oss/skills/blob/main/skills/render-private-services/SKILL.md

In Blueprints, you can wire the internal address of a private service using the `fromService` directive. This example shows how to get the combined host and port.

```yaml
- key: INTERNAL_API_URL
  fromService:
    name: my-api
    type: pserv
    property: hostport
```

--------------------------------

### Ruby Cron Job Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-cron-jobs/references/cron-patterns.md

Example of configuring a Ruby cron job on Render. 'bundle install' is used for dependency management, and the script is executed with 'bundle exec'.

```yaml
- type: cron
  name: daily-task
  runtime: ruby
  schedule: "0 0 * * *"
  buildCommand: bundle install
  startCommand: bundle exec ruby scripts/task.rb
```

--------------------------------

### Node.js Cron Job Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-cron-jobs/references/cron-patterns.md

Example of configuring a Node.js cron job on Render. Use 'npm ci' for dependency installation and ensure the script path is correct.

```yaml
- type: cron
  name: report-generator
  runtime: node
  schedule: "0 6 * * 1"
  buildCommand: npm ci
  startCommand: node scripts/weekly-report.js
```

--------------------------------

### Complete Blueprint Example with Services and Databases

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

A full-featured Blueprint defining multiple web services, a worker, a cron job, a static frontend, and PostgreSQL and Redis databases.

```yaml
services:
  # Web service
  - type: web
    name: web-app
    runtime: node
    plan: free
    region: oregon
    buildCommand: npm ci && npm run build
    startCommand: npm start
    branch: main
    autoDeploy: true
    healthCheckPath: /health
    envVars:
      - key: NODE_ENV
        value: production
      - key: DATABASE_URL
        fromDatabase:
          name: postgres
          property: connectionString
      - key: REDIS_URL
        fromDatabase:
          name: redis
          property: connectionString
      - key: JWT_SECRET
        sync: false

  # Background worker
  - type: worker
    name: queue-worker
    runtime: node
    plan: free
    buildCommand: npm ci
    startCommand: node worker.js
    envVars:
      - key: REDIS_URL
        fromDatabase:
          name: redis
          property: connectionString

  # Cron job
  - type: cron
    name: daily-cleanup
    runtime: node
    schedule: "0 3 * * *"
    buildCommand: npm ci
    startCommand: node scripts/cleanup.js
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: postgres
          property: connectionString

  # Static frontend
  - type: web
    name: frontend
    runtime: static
    buildCommand: npm ci && npm run build
    staticPublishPath: ./dist
    routes:
      - type: rewrite
        source: /*
        destination: /index.html

databases:
  - name: postgres
    databaseName: app_production
    user: app_user
    plan: free
    postgresMajorVersion: "15"
    ipAllowList: []

  - name: redis
    plan: free
    maxmemoryPolicy: allkeys-lru
    ipAllowList: []
```

--------------------------------

### Create a Web Service

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/direct-creation.md

Use this to create a new web service. Specify runtime, repository, build/start commands, plan, region, and environment variables.

```python
create_web_service(
  name: "my-api",
  runtime: "node",  # or python, go, rust, ruby, elixir, docker
  repo: "https://github.com/username/repo",
  branch: "main",  # optional, defaults to repo default branch
  buildCommand: "npm ci",
  startCommand: "npm start",
  plan: "free",  # free, starter, standard, pro, pro_max, pro_plus, pro_ultra
  region: "oregon",  # oregon, frankfurt, singapore, ohio, virginia
  envVars: [
    {"key": "NODE_ENV", "value": "production"}
  ]
)
```

--------------------------------

### Private Service Definition in render.yaml

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

Example of a private service configuration, including name, runtime, plan, build and start commands, suitable for internal APIs or database proxies.

```yaml
services:
  - type: pserv
    name: internal-api
    runtime: go
    plan: free
    buildCommand: go build -o bin/app
    startCommand: ./bin/app
```

--------------------------------

### Application Startup Log Pattern

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/log-analysis.md

Logs indicating a successful application startup and listening on a port.

```text
Server started successfully
Listening on port 10000
Database connected
```

--------------------------------

### Bash/Shell Cron Job Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-cron-jobs/references/cron-patterns.md

Example of configuring a Bash or Shell cron job on Render. The 'buildCommand' is set to 'true' as it's a no-op, and the start command executes the script.

```yaml
- type: cron
  name: sync-data
  runtime: python
  schedule: "*/30 * * * *"
  buildCommand: "true"
  startCommand: /bin/bash scripts/sync.sh
```

--------------------------------

### Cron Job Definition in render.yaml

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

Example of a cron job configuration, including name, runtime, schedule, build and start commands, and environment variables referencing a database connection string.

```yaml
services:
  - type: cron
    name: daily-backup
    runtime: node
    schedule: "0 2 * * *"
    buildCommand: npm ci
    startCommand: node scripts/backup.js
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: postgres
          property: connectionString
```

--------------------------------

### Static Runtime Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Example configuration for a static runtime. Specify the type, name, build command, and the path to the static publish directory.

```yaml
type: web
name: react-app
runtime: static
buildCommand: npm ci && npm run build
staticPublishPath: ./build
```

--------------------------------

### Worker Service Definition in render.yaml

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

Example of a worker service configuration, specifying name, runtime, build and start commands, and environment variables, including referencing a database connection string.

```yaml
services:
  - type: worker
    name: job-processor
    runtime: python
    plan: free
    buildCommand: pip install -r requirements.txt
    startCommand: celery -A tasks worker --loglevel=info
    envVars:
      - key: REDIS_URL
        fromDatabase:
          name: redis
          property: connectionString
```

--------------------------------

### Simulate Render Environment Locally

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/troubleshooting.md

Set environment variables for PORT and DATABASE_URL to mimic the Render environment. Install dependencies, build the project, and start the application locally. This helps in reproducing and debugging issues before deployment.

```bash
# Simulate Render environment
export PORT=10000
export DATABASE_URL="postgresql://..."
npm ci && npm run build && npm start
```

--------------------------------

### Pre-built Public Image Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Configuration example for deploying a pre-built public Docker image, specifying the image URL.

```yaml
type: web
name: prebuilt-app
runtime: image
image: ghcr.io/myorg/myapp:v1.2.3
```

--------------------------------

### Build Render CLI from Source

Source: https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md

Clone the Render CLI repository and build the executable from source code.

```bash
git clone git@github.com:render-oss/cli.git && cd cli && go build -o render
```

--------------------------------

### Verify Database Provisioning

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/error-patterns.md

Check if the database service is provisioned and active using the render CLI.

```bash
render services -o json
# Verify database exists and is active
```

--------------------------------

### Install TypeScript Workflow Dependencies

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/manual-scaffolding.md

Installs Node.js dependencies for a TypeScript workflow using `npm`. The `--prefix` flag ensures installation within the `workflows/` directory.

```bash
npm install --prefix workflows
```

--------------------------------

### TypeScript Workflows Entry Point Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/manual-scaffolding.md

Provides the main entry point for a TypeScript Render Workflows skill. Features a `ping` task with configurable retry settings and uses the Render SDK.

```typescript
import { task } from "@renderinc/sdk/workflows";

task(
  {
    name: "ping",
    retry: { maxRetries: 3, waitDurationMs: 1000, backoffScaling: 2.0 },
  },
  function ping(): string {
    return "pong";
  },
);

```

--------------------------------

### Multi-Service App Configuration with Projects and Environments

Source: https://github.com/render-oss/skills/blob/main/skills/render-blueprints/SKILL.md

Define a multi-service application structure with production and staging environments. This example shows how to configure web services, worker services, key-value stores, and databases, including cross-service environment variable wiring.

```yaml
projects:
  - name: my-app
    environments:
      - name: production
        services:
          - type: web
            name: api
            runtime: node
            plan: standard
            buildCommand: npm ci && npm run build
            startCommand: npm start
            envVars:
              - key: DATABASE_URL
                fromDatabase:
                  name: db
                  property: connectionString
              - key: REDIS_URL
                fromService:
                  type: keyvalue
                  name: cache
                  property: connectionString
              - key: API_SECRET
                sync: false

          - type: worker
            name: jobs
            runtime: node
            plan: starter
            buildCommand: npm ci
            startCommand: node worker.js
            envVars:
              - key: DATABASE_URL
                fromDatabase:
                  name: db
                  property: connectionString
              - key: REDIS_URL
                fromService:
                  type: keyvalue
                  name: cache
                  property: connectionString

          - type: keyvalue
            name: cache
            plan: starter
            maxmemoryPolicy: noeviction
            ipAllowList:
              - source: 0.0.0.0/0
                description: everywhere

        databases:
          - name: db
            plan: starter
```

--------------------------------

### Install Render Skills via Claude Code Plugin

Source: https://github.com/render-oss/skills/blob/main/README.md

Install Render skills within the Claude Code environment using its plugin system. Follow the two-step process for installation.

```bash
/plugin marketplace add render-oss/skills
```

```bash
/plugin install render@skills
```

--------------------------------

### Instance Type: Pro

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/quick-reference.md

The 'pro' instance type provides 2 CPUs and 4 GB of RAM.

```text
pro
2 CPU / 4 GB
```

--------------------------------

### Instance Type: Pro Ultra

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/quick-reference.md

The 'pro_ultra' instance type provides 16 CPUs and 32 GB of RAM. Access may require special request.

```text
pro_ultra
16 CPU / 32 GB
```

--------------------------------

### Start BullMQ worker command

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

Command to start the Node.js worker script.

```bash
node worker.js
```

--------------------------------

### Common Go Build Commands

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/runtimes.md

Examples of Go build commands. These commands compile your Go application, with options for output path, build tags, and linker flags.

```bash
go build -o bin/app .
```

```bash
go build -o bin/app cmd/server/main.go
```

```bash
go build -tags netgo -ldflags '-s -w' -o bin/app
```

--------------------------------

### Start Sidekiq worker command

Source: https://github.com/render-oss/skills/blob/main/skills/render-background-workers/references/queue-framework-setup.md

Command to start a Sidekiq worker process.

```bash
bundle exec sidekiq
```

--------------------------------

### pip Build Command

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/configuration-guide.md

Use 'pip install -r requirements.txt' for installing Python dependencies.

```yaml
buildCommand: pip install -r requirements.txt
# Already non-interactive
```

--------------------------------

### Render Services List (JSON Output)

Source: https://github.com/render-oss/skills/blob/main/skills/render-cli/SKILL.md

Lists all services and datastores. Use `-o json` for machine-readable output suitable for scripting.

```bash
render services -o json
```

--------------------------------

### Build Commands: apt

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `apt-get install -y <package>` for non-interactive package installation.

```shell
apt-get install -y <package>
```

--------------------------------

### Build Commands: pip

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `pip install -r requirements.txt` for non-interactive dependency installation.

```shell
pip install -r requirements.txt
```

--------------------------------

### Example .dockerignore file

Source: https://github.com/render-oss/skills/blob/main/skills/render-docker/references/optimization-guide.md

Exclude files and directories not needed for the Docker build or runtime image to reduce context size and prevent build errors.

```docker
node_modules
.git
.env
.env.*
__pycache__
*.pyc
.next
dist
build
*.log
.DS_Store
coverage
.vscode
.idea
```

--------------------------------

### Python Workflows Entry Point Example

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/manual-scaffolding.md

Defines the main entry point for a Python Render Workflows skill. Includes a basic `ping` task and configures default retry behavior.

```python
from render_sdk import Workflows, Retry

app = Workflows(
    default_retry=Retry(max_retries=3, wait_duration_ms=1000, backoff_scaling=2.0),
)

@app.task
def ping() -> str:
    return "pong"

if __name__ == "__main__":
    app.start()
```

--------------------------------

### Build Commands: pnpm

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `pnpm install --frozen-lockfile` for non-interactive dependency installation.

```shell
pnpm install --frozen-lockfile
```

--------------------------------

### Build Commands: yarn

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/deployment-details.md

Use `yarn install --frozen-lockfile` for non-interactive dependency installation.

```shell
yarn install --frozen-lockfile
```

--------------------------------

### Instance Type: Pro Plus

Source: https://github.com/render-oss/skills/blob/main/skills/render-workflows/references/quick-reference.md

The 'pro_plus' instance type provides 4 CPUs and 8 GB of RAM. Access may require special request.

```text
pro_plus
4 CPU / 8 GB
```

--------------------------------

### Example .dockerignore file

Source: https://github.com/render-oss/skills/blob/main/skills/render-debug/references/error-patterns.md

A sample .dockerignore file to exclude unnecessary files and directories from the Docker build context, which can prevent build failures and reduce build times.

```dockerignore
node_modules
.git
.env
*.log
```

--------------------------------

### Manual Scaling Configuration

Source: https://github.com/render-oss/skills/blob/main/skills/render-deploy/references/blueprint-spec.md

Configure a fixed number of instances for a web service.

```yaml
services:
  - type: web
    name: my-app
    runtime: node
    plan: standard
    numInstances: 3
```