> ## Documentation Index
> Fetch the complete documentation index at: https://ryvn.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Render to Ryvn migration guide

> Map Render concepts to Ryvn — services, installations, environments, environment variables, and variable groups — with side-by-side examples.

## Key conceptual difference

### Render's approach: all-in-one service definitions

In Render, each service is a complete, self-contained deployment unit. If you want the same application in test and production, you create two separate service definitions with duplicated build commands, even though the code and build process are identical. This leads to repetition and makes it harder to maintain consistency across environments.

### Ryvn's approach: separation of concerns

Ryvn separates **what you're building** (services) from **how you're deploying it** (installations):

* **Services**: Define the source code, repository, and build process once
* **Installations**: Configure deployment-specific settings like resources, scaling, and environment variables per environment

Why this matters:

**Guaranteed consistency** - The exact same container image that passes tests in staging is what runs in production. No more "works on my machine" or subtle build differences between environments.

**No more copy-paste** - When you need to update your build process, change it in one place. No hunting through dozens of duplicated service definitions to keep them in sync.

```yaml theme={null}
# Render: Duplicate services for each environment
services:
  - name: api-test   # Environment name conflated with service name
    type: web
    runtime: node
    repo: https://github.com/my-org/my-repo
    branch: test     # GitFlow branch name
    plan: standard
    buildCommand: npm install
    startCommand: npm start
    envVars: [...]

  - name: api-prod
    type: web                                # Same
    runtime: node                            # Same
    repo: https://github.com/my-org/my-repo  # Same
    branch: main
    plan: pro
    buildCommand: npm install                # Same
    startCommand: npm start
    envVars: [...]

# Ryvn: Build once, deploy many
kind: Service
metadata:
  name: api
spec:
  type: server
  repo: my-org/my-repo
  build:
    buildpack: nixpack
    command: "npm install"
---
kind: ServiceInstallation
metadata:
  name: api-test
spec:
  service: api
  environment: test
  config: |
    resources:
      requests:
        cpu: "1"
        memory: "2Gi"
    command: ["npm", "start"]
  env: [...]
---
kind: ServiceInstallation
metadata:
  name: api-production
spec:
  service: api
  environment: production
  config: |
    resources:
      requests:
        cpu: "2"
        memory: "4Gi"
    command: ["npm", "start"]
  env: [...]
```

## Quick mapping reference

### Service definition (build time)

| Render | Ryvn Service | Notes |
| - | - | - |
| `type: web` | `type: server` | Server type for web services |
| `type: worker` | `type: server` | Use server type |
| `type: cron` | `type: job` | Job type for scheduled tasks |
| `runtime: node` | `buildpack: nixpack` | For Node.js apps |
| `runtime: docker` | `dockerfile: path` | For Docker builds |
| `repo` | `repo` (without https) | Format: `owner/repo` |
| `buildCommand` | `build.command` | In service definition |

### Installation configuration (deploy time)

| Render | Ryvn Installation | Notes |
| - | - | - |
| `plan: standard` | 1 CPU, 2GB RAM | Set in `resources.requests` |
| `plan: pro` | 2 CPU, 4GB RAM | Set in `resources.requests` |
| `startCommand` | `command` | In installation config |
| `domains` | `ingress.hosts` | Requires full ingress config |
| `schedule` | `schedule` | For job type only |
| `envVars` | `env` | In installation |
| `envVars.fromGroup` | `variableGroups` | Import all keys via variable groups |
| `numInstances` | `replicas` | Fixed scaling |
| `scaling` | `autoscaling` | Dynamic scaling |

## Environment variables

```yaml theme={null}
# Render
envVars:
  - key: NODE_ENV
    value: production            # Plain value
  - fromGroup: database-config   # Import group
  - key: API_KEY
    sync: false                  # Secret without value

# Ryvn (inside a ServiceInstallation spec)
variableGroups:
  - name: database-config        # Import all keys from variable group
env:
  - key: NODE_ENV
    value: production            # Plain value
  - key: API_KEY
    isSecret: true               # Set value in platform UI
```

## Web service example

```yaml theme={null}
# Render
services:
  - type: web
    name: express-api
    runtime: node
    repo: https://github.com/my-org/api
    branch: main
    plan: pro
    buildCommand: npm install && npm build
    startCommand: npm start
    domains:
      - api.example.com
    scaling:
      minInstances: 2
      maxInstances: 10

# Ryvn
kind: Service
metadata:
  name: express-api
spec:
  type: server
  repo: my-org/api
  build:
    buildpack: nixpack
    command: "npm install && npm build"
---
kind: ServiceInstallation
metadata:
  name: express-api-production
spec:
  service: express-api
  environment: production
  config: |
    autoscaling:
      enabled: true
      minReplicas: 2
      maxReplicas: 10
    resources:
      requests:
        cpu: "2"      # Pro = 2 CPU
        memory: "4Gi" # Pro = 4GB
    ingress:
      enabled: true
      className: external-nginx
      hosts:
        - host: api.example.com
          paths:
            - path: /
              pathType: Prefix
      tls:
        - hosts:
            - api.example.com
          secretName: api-tls
    command: ["npm", "start"]
```

> [!WARNING]
>
> Ingress networking and NGINX annotations are deprecated. See
> [Ingress networking](https://ryvn.ai/docs/networking/migration-guides/ingress-networking.md) for what to use instead.

## Cron job example

```yaml theme={null}
# Render
services:
  - type: cron
    name: cleanup-job
    runtime: node
    repo: https://github.com/my-org/jobs
    branch: main
    schedule: "0 2 * * *"
    buildCommand: npm install
    startCommand: npm run cleanup

# Ryvn
kind: Service
metadata:
  name: cleanup-job
spec:
  type: job
  repo: my-org/jobs
  build:
    buildpack: nixpack
    command: "npm install"
---
kind: ServiceInstallation
metadata:
  name: cleanup-job-production
spec:
  service: cleanup-job
  environment: production
  config: |
    schedule: "0 2 * * *"
    resources:
      requests:
        cpu: "1"
        memory: "2Gi"
    command: ["npm", "run", "cleanup"]
```

## Migration steps

1. **Create variable groups** for your Render environment groups
2. **Define services** as resource YAML files with build configuration
3. **Add environments** with provider configuration
4. **Create installations** per environment with runtime config
5. **Configure Git Sync** in Ryvn Dashboard
6. **Push and deploy**

> [!NOTE]
>
> Key differences to remember:
>
> * Repository format: `owner/repo` not full GitHub URL
> * Build commands go in service definition
> * Start commands go in installation config
> * Resources must be explicit (no "plan" names)
> * Web services need explicit ingress configuration
