npx skills add ...
npx skills add firecrawl/openai-skills --skill render-deploy
npx skills add firecrawl/openai-skills --skill render-deploy
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.
The same skill content is published under more than one repo. The install counts are split across them; any of these commands works.
Render supports Git-backed services and prebuilt Docker image services.
This skill covers Git-backed flows:
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:
sandbox_permissions=require_escalated.Activate this skill when users want to:
Use this short prompt sequence before deep analysis to reduce friction:
Then proceed with the appropriate method below.
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:
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).
Both methods require a Git repository pushed to GitHub, GitLab, or Bitbucket. (If using runtime: image, the repo can be minimal and only contain render.yaml.)
| Method | Best For | Pros |
|---|---|---|
| Blueprint | Multi-service apps, IaC workflows | Version controlled, reproducible, supports complex setups |
| Direct Creation | Single services, quick deployments | Instant creation, no render.yaml file needed |
Use this decision rule by default unless the user requests a specific method. Analyze the codebase first; only ask if deployment intent is unclear (e.g., DB, workers, cron).
Use Direct Creation (MCP) when ALL are true:
Use Blueprint when ANY are true:
If unsure, ask a quick clarifying question, but default to Blueprint for safety. For a single service, strongly prefer Direct Creation via MCP and guide MCP setup if needed.
When starting a deployment, verify these requirements in order:
1. Confirm Source Path (Git vs Docker)
If using Git-based methods (Blueprint or Direct Creation), the repo must be pushed to GitHub/GitLab/Bitbucket. Blueprints that reference a prebuilt image still require a Git repo with render.yaml.
2. Check MCP Tools Availability (Preferred for Single-Service)
MCP tools provide the best experience. Check if available by attempting:
If MCP tools are available, you can skip CLI installation for most operations.
3. Check Render CLI Installation (for Blueprint validation)
If not installed, offer to install:
brew install rendercurl -fsSL https://raw.githubusercontent.com/render-oss/cli/main/bin/install.sh | sh4. MCP Setup (if MCP isn't configured)
If list_services() fails because MCP isn't configured, ask whether they want to set up MCP (preferred) or continue with the CLI fallback. If they choose MCP, ask which AI tool they're using, then provide the matching instructions below. Always use their API key.
Walk the user through these steps:
~/.cursor/mcp.json (replace <YOUR_API_KEY>):list_services().Walk the user through these steps:
<YOUR_API_KEY>):list_services().Walk the user through these steps:
list_services().If the user is on another AI app, direct them to the Render MCP docs for that tool's setup steps and install method.
After MCP is configured, have the user set the active Render workspace with a prompt like:
5. Check Authentication (CLI fallback only)
If MCP isn't available, use the CLI instead and verify you can access your account:
If render whoami fails or returns empty data, the CLI is not authenticated. The CLI won't always prompt automatically, so explicitly prompt the user to authenticate:
If neither is configured, ask user which method they prefer:
export RENDER_API_KEY="rnd_xxxxx" (Get from https://dashboard.render.com/u/*/settings#api-keys)render login (Opens browser for OAuth)6. Check Workspace Context
Verify the active workspace:
Or via CLI:
To list available workspaces:
If user needs to switch workspaces, they must do so via Dashboard or CLI (render workspace set).
Once prerequisites are met, proceed with deployment workflow.
Analyze the codebase to determine framework/runtime, build and start commands, required env vars, datastores, and port binding. Use the detailed checklists in references/codebase-analysis.md.
Create a render.yaml Blueprint file following the Blueprint specification.
Complete specification: references/blueprint-spec.md
Key Points:
plan: free unless user specifies otherwisesync: false (user fills these in Dashboard)web, worker, cron, static, or pservBasic Structure:
Service Types:
web: HTTP services, APIs, web applications (publicly accessible)worker: Background job processors (not publicly accessible)cron: Scheduled tasks that run on a cron schedulestatic: Static sites (HTML/CSS/JS served via CDN)pserv: Private services (internal only, within same account)Service type details: references/service-types.md Runtime options: references/runtimes.md Template examples: assets/
After creating render.yaml, always give the user a short, explicit checklist and run validation immediately when the CLI is available:
render whoami -o json (if not logged in, run render login or set RENDER_API_KEY)render blueprints validate
git add render.yaml && git commit -m "Add Render deployment configuration" && git push origin mainsync: falseValidate the render.yaml file to catch errors before deployment. If the CLI is installed, run the commands directly; only prompt the user if the CLI is missing:
Fix any validation errors before proceeding. Common issues:
name, type, runtime)Configuration guide: references/configuration-guide.md
IMPORTANT: You must merge the render.yaml file into your repository before deploying.
Ensure the render.yaml file is committed and pushed to your Git remote:
If there is no Git remote yet, stop here and guide the user to create a GitHub/GitLab/Bitbucket repo, add it as origin, and push before continuing.
Why this matters: The Dashboard deeplink will read the render.yaml from your repository. If the file isn't merged and pushed, Render won't find the configuration and deployment will fail.
Verify the file is in your remote repository before proceeding to the next step.
Get the Git repository URL:
This will return a URL from your Git provider. If the URL is SSH format, convert it to HTTPS:
| SSH Format | HTTPS Format |
|---|---|
git@github.com:user/repo.git | https://github.com/user/repo |
git@gitlab.com:user/repo.git | https://gitlab.com/user/repo |
git@bitbucket.org:user/repo.git | https://bitbucket.org/user/repo |
Conversion pattern: Replace git@<host>: with https://<host>/ and remove .git suffix.
Format the Dashboard deeplink using the HTTPS repository URL:
Example:
CRITICAL: Ensure the user has merged and pushed the render.yaml file to their repository before clicking the deeplink. If the file isn't in the repository, Render cannot read the Blueprint configuration and deployment will fail.
Provide the deeplink to the user with these instructions:
sync: false)The deployment will begin automatically. Users can monitor progress in the Render Dashboard.
After the user deploys via Dashboard, verify everything is working.
Check deployment status via MCP:
Look for status: "live" to confirm successful deployment.
Check for runtime errors (wait 2-3 minutes after deploy):
Check service health metrics:
If errors are found, proceed to the Post-deploy verification and basic triage section below.
For simple deployments without Infrastructure-as-Code, create services directly via MCP tools.
Repository must be pushed to a Git provider. Render clones your repository to build and deploy services.
Supported providers: GitHub, GitLab, Bitbucket
If no remote exists, stop and ask the user to create/push a remote or switch to Docker image deploy.
Note: MCP does not support creating image-backed services. Use the Dashboard/API for prebuilt Docker image deploys.
Use the concise steps below, and refer to references/direct-creation.md for full MCP command examples and follow-on configuration.
Use references/codebase-analysis.md to determine runtime, build/start commands, env vars, and datastores.
Create the service (web or static) and any required databases or key-value stores. See references/direct-creation.md.
If MCP returns an error about missing Git credentials or repo access, stop and guide the user to connect their Git provider in the Render Dashboard, then retry.
Add required env vars via MCP after creation. See references/direct-creation.md.
Remind the user that secrets can be set in the Dashboard if they prefer not to pass them via MCP.
Check deploy status, logs, and metrics. See references/direct-creation.md.
For service discovery, configuration details, quick commands, and common issues, see references/deployment-details.md.
Keep this short and repeatable. If any check fails, fix it before redeploying.
live and serving traffic0.0.0.0:$PORT)Detailed checklist and commands: references/post-deploy-checks.md
If the service fails to start or health checks time out, use the basic triage guide: references/troubleshooting-basics.md
If deployment fails due to network issues (timeouts, DNS errors, connection resets), rerun the deploy with escalated permissions (use sandbox_permissions=require_escalated). The deploy requires escalated network access when sandbox networking blocks outbound requests.
Example guidance to the user:
Optional: If you need deeper diagnostics (metrics/DB checks/error catalog), suggest installing the
render-debug skill. It is not required for the core deploy flow.*
claude mcp add --transport http render https://mcp.render.com/mcp --header "Authorization: Bearer <YOUR_API_KEY>"export RENDER_API_KEY="<YOUR_API_KEY>"codex mcp add render --url https://mcp.render.com/mcp --bearer-token-env-var RENDER_API_KEYSet my Render workspace to [WORKSPACE_NAME]# Check if user is logged in (use -o json for non-interactive mode)
render whoami -o jsonget_selected_workspace()render workspace current -o jsonlist_workspaces()services:
- type: web
name: my-app
runtime: node
plan: free
buildCommand: npm ci
startCommand: npm start
envVars:
- key: DATABASE_URL
fromDatabase:
name: postgres
property: connectionString
- key: JWT_SECRET
sync: false # User fills in Dashboard
databases:
- name: postgres
databaseName: myapp_db
plan: freerender whoami -o json # Ensure CLI is authenticated (won't always prompt)
render blueprints validategit add render.yaml
git commit -m "Add Render deployment configuration"
git push origin maingit remote get-url originhttps://dashboard.render.com/blueprint/new?repo=<REPOSITORY_URL>https://dashboard.render.com/blueprint/new?repo=https://github.com/username/repo-namelist_deploys(serviceId: "<service-id>", limit: 1)list_logs(resource: ["<service-id>"], level: ["error"], limit: 20)get_metrics(
resourceId: "<service-id>",
metricTypes: ["http_request_count", "cpu_usage", "memory_usage"]
)git remote -v # Verify remote exists
git push origin main # Ensure code is pushedThe deploy needs escalated network access to deploy to Render. I can rerun the command with escalated permissions—want me to proceed?