Generated banner for Render Env Vars
Generated logo for Render Env Vars

Render Env Vars

RenderOfficialCreated by Render

  • Skill
  • Tool integration
  • Cloud and DevOps
  • MIT
  • No issues found

From the author

Configures environment variables, secrets, and env groups on Render. Use when the user needs to set env vars, wire secrets between services, create env groups, use generateValue, set sync: false, or troubleshoot missing or incorrect environment variable values in Blueprints or the Dashboard.
— the description by Render

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

This skill provides a structured approach to configuring environment variables, secrets, and environment groups on the Render platform. It emphasizes safe configuration management, distinguishing between Dashboard, Blueprint, and API-driven workflows. The skill guides users through wiring services, handling platform-injected variables, and troubleshooting common runtime issues like port binding and concurrency settings, while strictly adhering to current platform documentation.

What it does

  • Configures environment variables and secrets via Dashboard or Blueprints
  • Manages shared configuration using environment groups
  • Wires cross-resource dependencies like databases or services
  • Troubleshoots missing variables and platform-injected defaults
  • Provides guidance on sync behaviors and secret generation
  • Ensures secure handling of sensitive configuration data

When to use it

  • When adding, updating, or removing environment variables or secrets
  • When setting up shared configuration across multiple services
  • When wiring services using fromDatabase, fromService, or fromGroup
  • When debugging issues with port binding or worker concurrency
  • When reconciling differences between Dashboard and Blueprint configurations

Advantages

  • Promotes consistent and secure configuration practices
  • Reduces errors by referencing live platform documentation
  • Simplifies complex service wiring in Blueprint files
  • Helps resolve common runtime environment variable conflicts

Usage examples

“How do I add a new secret to my Render web service?”
The agent will guide you to the appropriate configuration surface (Dashboard or Blueprint) and explain how to securely add the secret without exposing it in logs or source control.
“My service is failing to bind to the correct port, what should I check?”
The agent will help you inspect your start command and environment variables, ensuring you are correctly using the $PORT variable and binding to 0.0.0.0.
“How can I share a database connection string across multiple services?”
The agent will explain how to use environment groups or the fromDatabase syntax in your Blueprint to securely share the connection details.

Install

  1. Download the skill as a ZIP:

    https://autogineer.com/agent-skills/render-oss/render-env-vars/download
  2. Unzip it into the cross-client skills folder of your project:

    mkdir -p .agents/skills && unzip render-env-vars.zip -d .agents/skills

Documentation by Render

Environment Variables on Render

Before inspecting or changing environment variables, secrets, secret files, or environment groups, read references/environment-variables.md for the current documentation, source-of-truth, safety, and mutation workflow.

Blueprint wiring examples and language-specific application notes live under references/.

When to Use This Skill

Use this skill when users want to:

  • Add, change, or remove environment variables or secrets

  • Understand Dashboard vs Blueprint vs API/MCP flows

  • Use environment groups for shared configuration

  • Wire fromDatabase, fromService, fromGroup, sync: false, or generateValue in Blueprints

  • Debug missing vars, secret files, precedence, or platform-injected names

For full Blueprint authoring, pair with render-blueprints. For first-time deploys, render-deploy. For web service behavior and ports, render-web-services.

Blueprint Wiring (Summary)

After reading references/environment-variables.md, use references/wiring-reference.md for task-specific fromDatabase, fromService, and fromGroup examples. Consult render-blueprints for the complete Blueprint workflow.

Platform-Injected Variables

Use the current default-variable reference fetched through references/environment-variables.md instead of relying on a fixed catalog. Language-specific application notes remain in references/platform-variables.md.

Runtime-Specific Defaults

Always bind HTTP servers to 0.0.0.0 and PORT (or the stack’s documented port env) unless using a static site or custom Docker entrypoint.

  • When diagnosing a port-binding failure, first establish whether the service uses a native runtime or Docker and inspect its actual start command; the applicable defaults differ.

  • For a web service, PORT defaults to 10000. Prefer reading $PORT in the start command rather than hardcoding that number or setting PORT merely to match an arbitrary hardcoded port.

  • Native Python services currently receive GUNICORN_CMD_ARGS with a default bind to 0.0.0.0:10000. A custom Gunicorn start command should bind to 0.0.0.0:$PORT so the process and Render's health checks use the same port.

Common Issues

WEB_CONCURRENCY defaults differ for some older and newer services. When debugging worker counts, compare service creation date and explicit overrides, then confirm current behavior using references/environment-variables.md and references/platform-variables.md.

References

  • references/environment-variables.md — Current configuration docs, secret handling, groups, platform variables, and mutation safety

  • references/wiring-reference.md — Blueprint cross-resource wiring examples and workspace edge cases

  • references/platform-variables.md — Concurrency, native-runtime versus Docker behavior, and application parsing notes

  • render-blueprints — Full Blueprint authoring, validation, multi-service layouts

  • render-deploy — First deploy, repo requirements, MCP vs YAML

  • render-web-services — Ports, health checks, scaling behavior tied to env-driven servers

<!-- shared:documentation-retrieval -->

Current documentation retrieval

Whenever this skill directs you to consult current Render documentation:

  1. Retrieve the linked Markdown document directly with an available URL-fetching tool or HTTP client, such as curl. Do not substitute web-search summaries for the document.

  2. Confirm that retrieval succeeded and returned the expected document, then read its contents. Saving a file or printing its path is not sufficient.

  3. If the request fails or your tool cannot read the Markdown response, open and read the linked HTML version instead.

  4. If neither version can be retrieved, disclose that the current reference is unavailable and follow any topic-specific fallback in the skill. Use bundled guidance only for stable constraints, and do not guess at changeable platform details.

When a task requires multiple references, apply this workflow to each one and distinguish the documents you verified from those that remain unavailable.

<!-- /shared:documentation-retrieval -->

Files

references/wiring-reference.md

Blueprint environment variable wiring

Read environment-variables.md first for current syntax discovery, secret handling, precedence, and mutation safety. This reference retains task-specific cross-resource wiring examples. Pair it with the render-blueprints skill for service structure, previews, and validation.

fromDatabase — database properties

Reference a database defined in the same Blueprint (name must match the resource’s name).

Available properties (use the subset your app needs):

  • connectionString

  • connectionPoolString (when managed PgBouncer is enabled)

  • host

  • port

  • user

  • password

  • database

databases:
  - name: mydb
    databaseName: myapp
    user: myuser

services:
  - type: web
    name: api
    envVars:
      - key: DATABASE_URL
        fromDatabase:
          name: mydb
          property: connectionString
      - key: DATABASE_POOL_URL
        fromDatabase:
          name: mydb
          property: connectionPoolString
      - key: PGHOST
        fromDatabase:
          name: mydb
          property: host
      - key: PGPORT
        fromDatabase:
          name: mydb
          property: port
      - key: PGUSER
        fromDatabase:
          name: mydb
          property: user
      - key: PGPASSWORD
        fromDatabase:
          name: mydb
          property: password
      - key: PGDATABASE
        fromDatabase:
          name: mydb
          property: database

fromService — Key Value

Use type: keyvalue with one of: connectionString, host, or port. If an application needs host:port, combine the separate host and port values.

services:
  - type: keyvalue
    name: cache
    ipAllowList: []

  - type: web
    name: api
    envVars:
      - key: REDIS_URL
        fromService:
          name: cache
          type: keyvalue
          property: connectionString
      - key: REDIS_HOST
        fromService:
          name: cache
          type: keyvalue
          property: host
      - key: REDIS_PORT
        fromService:
          name: cache
          type: keyvalue
          property: port

fromService — private service or web service

For private services (pserv) or web services, typical properties:

  • host — internal hostname

  • hostport — host:port combined

Alternatively, reference a specific env var exposed by the other service with envVarKey (when supported for that link type—confirm in Dashboard-generated Blueprints for your service types).

services:
  - type: pserv
    name: internal-api
    runtime: docker
    # ...

  - type: web
    name: gateway
    envVars:
      - key: INTERNAL_API_HOST
        fromService:
          name: internal-api
          type: pserv
          property: host
      - key: INTERNAL_API_HOSTPORT
        fromService:
          name: internal-api
          type: pserv
          property: hostport
  - key: UPSTREAM_TOKEN
    fromService:
      name: internal-api
      type: web
      envVarKey: SERVICE_TOKEN

(Adjust type to match the target service: web, pserv, etc.)

fromGroup — environment group

Links all variables from the named group. Group must exist (or be created in the same Blueprint workflow, depending on your org’s pattern).

services:
  - type: web
    name: app
    envVars:
      - fromGroup: shared-config
      - key: SERVICE_SPECIFIC
        value: only-on-app

Edge cases

  • fromService / fromDatabase outside the Blueprint file — You may reference resources that are not declared in render.yaml only if they already exist in the same Render workspace (same team/account context) and names match. Otherwise provision fails at apply time.

Minimal multi-pattern example

services:
  - type: web
    name: full-example
    runtime: node
    buildCommand: npm install && npm run build
    startCommand: npm start
    envVars:
      - fromGroup: baseline
      - key: PUBLIC_API_URL
        value: https://api.example.com
      - key: WEBHOOK_SIGNING_SECRET
        generateValue: true
      - key: THIRD_PARTY_API_KEY
        sync: false
      - key: DATABASE_URL
        fromDatabase:
          name: prod-db
          property: connectionString
      - key: REDIS_URL
        fromService:
          name: sessions-kv
          type: keyvalue
          property: connectionString

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

The author says: Render Dashboard, CLI, or MCP tools

Security

No issues found by our static scan· No issues found

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by
Render
Publisher
Render (Official)
Source
render-oss/skills · skills/render-env-vars · commit b985a63
Licence
MIT License (redistribution allowed)
  • LICENSE (added by AutoGineer from LICENSE)
  • ATTRIBUTION.md (written by AutoGineer)
Synced

AutoGineer is not affiliated with or endorsed by Render or Render.

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download render-env-vars.zip