# Ample vs Render: which is better for apps deployed by coding agents?

Ample and Render compared on databases, storage, isolation and agent access, with sourced limits and steps to move a Render service.

## The Short Version

Render is the better choice for fixed-price services in a chosen region, especially from Docker images. Ample is the better choice when a coding agent deploys many small apps: Postgres, MySQL, Redis and MongoDB created automatically, S3-compatible buckets, and signup with no person in the loop.

## Who This Is For

Both run long-running web services and workers from a repository with managed Postgres. They differ in free-tier limits, which databases and storage are built in, how spending stops, and whether an agent can sign up on its own.

## Ample and Render Side by Side

| Feature                          | Ample                                                                                         | Render                                                                                             |
|----------------------------------|-----------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------|
| Free Plan                        | Yes. Free is $0 for up to 2 apps, with no card.                                             | Free web services (512 MB, 0.1 CPU) with 750 instance hours a month and no card. Free Postgres is deleted 30 days after creation, after a 14-day grace period. |
| Paid Plans                       | Pro is $20 a month for up to 10 apps and Scale $99 a month for up to 50. Every plan includes compute, databases, S3 storage, a CDN and scheduled jobs. | Workspace plans from $0 (Hobby) or $25 a month (Pro), plus fixed compute per service: $7 a month for 0.5 CPU and 512 MB, $25 for 1 CPU and 2 GB. |
| Spending Limit                   | A hard spending cap on every plan, on by default: apps pause and are never billed past it.   | No general spend cap documented; the only hard limit is on build minutes.                          |
| How Apps Run                     | Each app runs as a normal long-running process in its own microVM with its own kernel.        | Containers with fixed CPU and memory per instance. Isolation technology is not documented.         |
| Long-running Servers and Workers  | Yes. Web services and background workers (`--kind worker`) run as ordinary processes, with WebSockets, streaming responses and requests of 10 minutes or more. | Yes. Web services, private services, background workers and workflows; WebSockets have no fixed timeout.  |
| Languages                        | Node, Python, Go, Ruby, PHP, Java, .NET, Elixir, Rust and static sites, detected from the repository. | Node.js, Bun, Python, Ruby, Go, Rust and Elixir natively; PHP, .NET and Java through Docker.  |
| Docker Images                    | Not needed: Ample Computer builds from source and runs your start command; a Dockerfile's own steps are not run. | Yes, built with BuildKit or pulled from a registry.                                             |
| Databases                        | Managed Postgres (with pgvector), MySQL, Redis and MongoDB, each in its own microVM, created automatically when the code needs one. | Managed Postgres and Key Value (Valkey 8, Redis-compatible). No managed MySQL or MongoDB.       |
| Object Storage                   | S3-compatible buckets, optionally published through Ample's CDN.                              | No first-party object storage found in Render's pricing or docs.                                  |
| Persistent Disk                  | Persistent volumes attached to the app.                                                      | Persistent disks at $0.25 per GB a month; a service with a disk runs one instance.               |
| Custom Domains and TLS           | Custom domains with automatic TLS.                                                            | Custom domains with automatic TLS, including wildcards; 2 included on Hobby.                      |
| Regions                          | The USA and Europe, placed automatically; the USA is the default.                             | 5 regions; a service's region cannot be changed.                                                  |
| Scheduled Jobs                   | Scheduled jobs: a command or HTTP request on a cron schedule (any time zone) or interval, with retries and run history (`ample job create`). | Cron job services (runs stop after 12 hours).                                                  |
| Agent Access                     | CLI, remote MCP server (OAuth), A2A endpoint and agent skills. Deploys are synchronous and return JSON with an exit code: 0 live, 1 failed, 2 needs input. | Hosted MCP at mcp.render.com that can create services and read logs, plus plugins for Claude Code, Cursor and Codex and agent skills. |
| Agent Signup Without a Person    | Yes. `ample auth signup` creates an account with no browser, card or CAPTCHA; a person claims it by email within 48 hours. | No. A person authorizes the agent through OAuth or an API key.                                   |

## Choose Ample When

- ✓ You want apps that do not spin down for a minute-long wake, and a database that is not deleted after 30 days.
- ✓ You need MySQL, MongoDB or S3-compatible buckets alongside Postgres and Redis.
- ✓ A coding agent should create the account and deploy with no person in the loop.

## Choose Render When

- ✓ Your services must be always on and you are happy paying a fixed monthly price per instance.
- ✓ You need a region outside the USA and Europe, autoscaling across instances or Docker images.
- ✓ You describe infrastructure in `render.yaml` Blueprints today.

## Move a Render Service to Ample

1. **Read your Blueprint or service settings.** Note each service's build command, start command, pre-deploy command and health check path from `render.yaml` or the dashboard.

2. **Collect environment variables.** Copy variables into a local env file. Replace `fromDatabase` references with real connection strings, or leave `DATABASE_URL` out and let Ample create a database.

3. **Plan and deploy.** Ample detects the runtime and listens on its own port variable, so drop any hard-coded port 10000.

```bash
$ ample plan --write && ample up
```

4. **Move data.** Dump Render Postgres through its external URL with `pg_dump` and restore it into the Ample database; Key Value data can usually be re-warmed.

5. **Point your domain.** Add the domain to the app, update DNS to the target Ample prints, and keep the old app running until the new one answers on the domain.

```bash
$ ample domain add <app-name> www.example.com
```

## Frequently Asked Questions

**Does Ample have object storage?**

Yes. `ample bucket create` makes an S3-compatible bucket with its own credentials, and a bucket can be published through Ample's CDN. Render does not list a first-party object store.

**Can an agent deploy to Ample without me?**

Yes. `ample auth signup` creates an account with no browser. You claim it by email within 48 hours to keep it.

## Sources

- [Ample agent instructions (AGENTS.md)](/content/AGENTS.md)
- [Render pricing](https://render.com/pricing)
- [Render free tier](https://render.com/docs/free.md)
- [Render build pipeline limits](https://render.com/docs/build-pipeline.md)
- [Render service types](https://render.com/docs/service-types.md)
- [Render WebSockets](https://render.com/docs/websocket.md)
- [Render native runtimes](https://render.com/docs/native-runtimes.md)
- [Render Key Value](https://render.com/docs/key-value.md)
- [Render docs index](https://render.com/llms.txt)
- [Render persistent disks](https://render.com/docs/disks.md)
- [Render custom domains](https://render.com/docs/custom-domains.md)
- [Render regions](https://render.com/docs/regions.md)
- [Render MCP server](https://render.com/docs/mcp-server.md)
- [Render LLM support](https://render.com/docs/llm-support.md)
- [Render agent setup](https://render.com/agents.md)
- [Render Blueprint spec](https://render.com/docs/blueprint-spec.md)
