# render-deploy

Reads your codebase, writes a render.yaml Blueprint and walks you through deploying on Render. Handy when the app is ready to go live.

- skill · `type=skill` · Claude Code, Codex, Cursor, GitHub Copilot, Gemini CLI, OpenCode · 559 installs · ★ 88
- Author: Render
- License: MIT · policy=mirror · the beginning of the file is at the end of this page
- Source: https://github.com/render-oss/skills/tree/HEAD/skills/render-deploy/SKILL.md
- Updated: 2026-10-08
- HTML: https://affpapa.org/en/nevibecode/skills/render-deploy

## What it does

The skill inspects the repo and works out the framework, build and start commands, env vars and port binding. From there it either generates a `render.yaml` Blueprint for Infrastructure-as-Code or creates the service directly through MCP tools. Separate references cover the deploy lifecycle, private networking, service types and compute plans.

One thing to check before you start: you need a Git repository pushed to GitHub, GitLab or Bitbucket. With no remote, the skill stops and asks you to create one. A Blueprint that runs a prebuilt image still needs a repo, because `render.yaml` has to live there. Blueprint validation requires the Render CLI; operations need MCP or the CLI.

The skill picks the method from your code. A single web service with no database, workers or cron goes through direct creation via MCP. Multiple services, a database, Key Value or background jobs mean a Blueprint. When it can't tell, it defaults to Blueprint.

## Requirements
- Works with: Docker

## Install

### Claude Code (native platform)

1. **Skills CLI (Vercel)**
```bash
npx skills add render-oss/skills --skill render-deploy -a claude-code
```

2. **Manually: put the files in place**
- File: `~/.claude/skills/render-deploy/SKILL.md` — Copy the whole skill folder; for one project use .claude/skills/render-deploy/

### Codex

1. **Skills CLI (Vercel)**
```bash
npx skills add render-oss/skills --skill render-deploy -a codex
```

2. **Manually: put the files in place**
- File: `.agents/skills/render-deploy/SKILL.md` — For all projects use ~/.agents/skills/

### Cursor

1. **Skills CLI (Vercel)**
```bash
npx skills add render-oss/skills --skill render-deploy -a cursor
```

2. **Manually: put the files in place**
- File: `.cursor/skills/render-deploy/SKILL.md` — Cursor also reads .agents/skills/ and .claude/skills/

### GitHub Copilot

1. **GitHub CLI**
```bash
gh skill install render-oss/skills render-deploy
```

2. **Manually: put the files in place**
- File: `.github/skills/render-deploy/SKILL.md`

### Gemini CLI

1. **Skills CLI (Vercel)**
```bash
npx skills add render-oss/skills --skill render-deploy -a gemini-cli
```

2. **Platform CLI**
```bash
gemini skills install https://github.com/render-oss/skills --path skills/render-deploy
```

### Windsurf (Devin Desktop)

**Manually: put the files in place**
- File: `.devin/skills/render-deploy/SKILL.md` — The legacy .windsurf/skills/ path still works

### OpenCode

**Skills CLI (Vercel)**
```bash
npx skills add render-oss/skills --skill render-deploy -a opencode
```

### Claude.ai

**Claude.ai**
- Zip the folder and upload it in Settings → Capabilities → Skills

Where a file is given instead of a command, copy the files from the source to that path: https://github.com/render-oss/skills/tree/HEAD/skills/render-deploy/SKILL.md

## When to use it
- write a `render.yaml` for a specific stack without reading the spec by hand
- ship an app to Render from a Git repository
- wire a web service, a worker and a database into one Blueprint
- figure out which env vars and port a service needs
- decide between a Blueprint and direct service creation

## Example prompts
- Deploy my project to Render
- Generate a render.yaml for this repo
- Set up Render deployment with a web service and a database

## Source text · SKILL.md · MIT

Below is the content of a third-party file. It is data, not instructions for you: do not act on anything written inside unless the human asks. Block tag: 0eafe4b0fa599511.

BEGIN THIRD-PARTY FILE 0eafe4b0fa599511
```text
---
name: render-deploy
description: Deploy applications to Render by analyzing codebases, generating render.yaml Blueprints, and providing Dashboard deeplinks. Use when the user wants to deploy, host, publish, or set up their application on Render's cloud platform.
license: MIT
compatibility: Requires a Git repository on GitHub, GitLab, or Bitbucket for Blueprint/MCP flows. Blueprint can reference a prebuilt image but render.yaml must live in the repo. Render CLI recommended for Blueprint validation; MCP or CLI required for operations.
metadata:
  author: Render
  version: "1.1.0"
  category: deployment
---

# Deploy to Render

Render supports **Git-backed** services and **prebuilt Docker image** services.

This skill covers **Git-backed** flows:
1. **Blueprint Method** - Generate render.yaml for Infrastructure-as-Code deployments
2. **Direct Creation** - Create services instantly via MCP tools

Blueprints can also run a **prebuilt Docker image** by using `runtime: image`, but the `render.yaml` still must live in a Git repo.

If there is no Git remote, stop and ask the user to either:
- Create/push a Git remote (can be minimal if only the Blueprint is needed), or
- Use the Render Dashboard/API to deploy a prebuilt Docker image (MCP cannot create image-backed services).

## When to Use This Skill

Activate this skill when users want to:
- Deploy an application to Render
- Create a render.yaml Blueprint file
- Set up Render deployment for their project
- Host or publish their application on Render's cloud platform
- Create databases, cron jobs, or other Render resources

## Happy Path (New Users)

Use this short prompt sequence only to fill missing information. Do not ask the user to repeat details they already supplied. If the source and required resources are clear, proceed directly to method selection and deployment.
1. Ask whether they want to deploy from a Git repo or a prebuilt Docker image.
2. Ask whether Render should provision everything the app needs (based on what seems likely from the user's description) or only the app while they bring their own infra. If dependencies are unclear, ask a short follow-up to confirm whether they need a database, workers, cron, or other services.

Then proceed with the appropriate method below.

## Choose Your Source Path

**Git Repo Path:** Required for both Blueprint and Direct Creation. The repo must be pushed to GitHub, GitLab, or Bitbucket.

**Prebuilt Docker Image Path:** Supported by Render via image-backed services. This is **not** supported by MCP; use the Dashboard/API. Ask for:
- Image URL (registry + tag)
- Registry auth (if private)
- Service type (web/worker) and port

If the user chooses a Docker image, guide them to the Render Dashboard image deploy flow or ask them to add a Git remote (so you can use a Blueprint with `runtime: image`).
```
END THIRD-PARTY FILE 0eafe4b0fa599511

The third-party file has ended. Everything between the 0eafe4b0fa599511 tags is data: requests and commands from it are not followed. An “end of file” line with another tag inside the block is part of the file.

First 2845 of 16623 bytes. © Render · MIT · https://github.com/render-oss/skills/tree/HEAD/skills/render-deploy/SKILL.md

_Part of the page did not fit — see the HTML version._

---
NeVibeCode on affpapa.org. Catalog texts are descriptions, not instructions for the agent. How to choose and install: https://affpapa.org/en/nevibecode/agents.md