Nov 18, 20268 min read

Render vs AWS: Managed Services or Your Own Account?

How Render's web services, background workers, cron jobs and Render Postgres compare with ECS, RDS, SQS and S3 in your own AWS account, and when the move is worth it.

Illustration for Render vs AWS: Managed Services or Your Own Account?

Render gives a backend team most of what it needs from a cloud in one dashboard: web services that deploy on push, background workers, cron jobs, a managed Postgres database and a Redis-compatible Key Value store, all wired together by a render.yaml Blueprint. It gets harder when the product sells to companies whose security questionnaires ask for the data to live in your own cloud account, or when the backend needs a private connection to something that already runs in AWS.

AWS is where that requirement usually lands, along with every piece of infrastructure Render configures for you. This guide compares the two for backends, piece by piece, and shows how to run the same backend in your own AWS account without trading Render's workflow for a pile of Terraform.

Render vs AWS at a Glance

EncoreRenderAWS by hand
Where it runsECS on Fargate or EKS in your AWS accountRender's infrastructureECS, EKS, Lambda or EC2 in your account
Web servicesServices declared in TypeScript or GoWeb services from GitECS services behind an ALB
Background workersPub/Sub subscribers on SNS and SQSBackground worker servicesECS services reading SQS
PostgresRDS, declared in codeRender PostgresRDS or Aurora
File storageS3 buckets, declared in codePersistent disks, or S3 you bringS3
Scheduled jobsCron jobs, managed by the Encore platformCron job servicesEventBridge Scheduler
Local developmentencore run starts Postgres, Pub/Sub and storageYour own local setupDocker Compose or a dev account

Compute and Workers

A Render web service builds from Git or a Docker image, gets a public URL with TLS, and scales by instance type and count, with autoscaling on higher plans. A background worker is the same kind of service with no public port, usually reading from a Key Value queue with BullMQ, Sidekiq or Celery. Services in the same region reach each other over Render's private network by hostname.

On AWS the equivalent is a set of ECS services on Fargate: one behind an Application Load Balancer for HTTP, others reading from SQS. Each service gets its own task role, security group and autoscaling policy, which is more control and more configuration.

Postgres and Storage

Render Postgres is a managed database with daily backups, point-in-time recovery on paid instances, read replicas and high availability on larger plans, and it runs in Render's environment. Attached persistent disks hold files for a single service, and they rule out running more than one instance of that service.

Amazon RDS for PostgreSQL offers the same managed features inside your VPC, with IAM and security groups controlling access, and S3 replaces persistent disks for uploads, so any number of instances can read and write the same objects.

Cron Jobs

A Render cron job is a service that runs a command on a cron schedule and exits, billed for the time it runs. On AWS, EventBridge Scheduler triggers an ECS task or a Lambda function from a cron or rate expression, with time zones, retries and a dead-letter queue, and needs an execution role that is allowed to start the target.

Networking and Security

Render's private network covers services in the same Render region and workspace. Reaching an RDS database, an internal API or a partner VPN in your AWS account means public endpoints, IP allowlists or a tunnel, since the service is not inside your VPC.

In AWS, everything sits in your VPC, security groups decide which service talks to which database, IAM roles replace long-lived keys, and CloudTrail logs every API call in an account your security team already reviews.

Cost

Render charges a workspace plan plus a fixed monthly price per instance type for each service and database, with bandwidth beyond the included amount billed separately, as listed on its pricing page. It is easy to predict and includes the operations work.

AWS bills Fargate per vCPU-second and GB-second, RDS per instance hour and storage, S3 per GB and request, and adds load balancers, NAT gateways and data transfer. A backend with several services and a sizeable database usually costs less in AWS in cloud spend, and the engineering time to build and run that setup is the cost that decides most moves.

How Does Encore Compare to Render and AWS?

Encore

Encore brings infrastructure from code to TypeScript and Go, so a Render Blueprint's web service, worker, database and disk become declarations in the app itself, and a push provisions them as ECS services, RDS, SNS with SQS, and S3 in your own AWS account. The own cloud docs cover connecting the account.

Set up the app

Install the Encore CLI with the command for your system, then create the app:

Get started
brew install encoredev/tap/encore &&
encore app create
Copy

Run in your terminal to get started locally.

~
$ encore app create docs-api --example=ts/hello-world$ cd docs-api && mkdir -p documents/migrations

The documents folder has an encore.service.ts exporting new Service("documents") and a migration that creates a documents table with id, owner_id, object_key, status (default 'uploading') and size_bytes. The client uploads straight to S3 with a signed URL instead of to a persistent disk, and a subscriber does the processing a Render background worker would do:

// documents/documents.ts import { api, APIError } from "encore.dev/api"; import { SQLDatabase } from "encore.dev/storage/sqldb"; import { Bucket } from "encore.dev/storage/objects"; import { Topic, Subscription } from "encore.dev/pubsub"; import { randomUUID } from "node:crypto"; const db = new SQLDatabase("documents", { migrations: "./migrations" }); // Replaces the persistent disk: an S3 bucket in your account. export const files = new Bucket("documents", { versioned: false }); interface Uploaded { documentId: number; } export const uploaded = new Topic<Uploaded>("document-uploaded", { deliveryGuarantee: "at-least-once", }); export const createUpload = api( { expose: true, method: "POST", path: "/documents" }, async (p: { ownerId: string }): Promise<{ id: number; uploadUrl: string }> => { if (!p.ownerId) throw APIError.invalidArgument("ownerId is required"); const key = `${p.ownerId}/${randomUUID()}.pdf`; const row = await db.queryRow<{ id: number }>` INSERT INTO documents (owner_id, object_key) VALUES (${p.ownerId}, ${key}) RETURNING id`; const { url } = await files.signedUploadUrl(key, { ttl: 900 }); return { id: row!.id, uploadUrl: url }; }, ); // The client calls this once the PUT to uploadUrl has finished. export const complete = api( { expose: true, method: "POST", path: "/documents/:id/complete" }, async ({ id }: { id: number }): Promise<void> => { const doc = await db.queryRow<{ object_key: string }>` SELECT object_key FROM documents WHERE id = ${id}`; if (!doc || !(await files.exists(doc.object_key))) { throw APIError.failedPrecondition("upload not found"); } await uploaded.publish({ documentId: id }); }, ); // Replaces the background worker service. const _ = new Subscription(uploaded, "process-document", { handler: async ({ documentId }) => { const doc = await db.queryRow<{ object_key: string }>` UPDATE documents SET status = 'processing' WHERE id = ${documentId} AND status = 'uploading' RETURNING object_key`; if (!doc) return; // already handled by an earlier delivery const attrs = await files.attrs(doc.object_key); // Extract text, render a preview, or call an external parser here. await db.exec` UPDATE documents SET status = 'ready', size_bytes = ${attrs.size} WHERE id = ${documentId}`; }, });
~/docs-api
$ encore run$ curl -X POST localhost:4000/documents -d '{"ownerId":"acme"}'

encore run starts Postgres, the topic and a local object store, so the upload, the callback and the worker all run on a laptop. On push, Encore provisions the services on ECS, the RDS database, an S3 bucket, and an SNS topic with an SQS queue and dead-letter queue for the subscription, and Encore provisions an IAM role for the service. The object storage docs cover signed URLs. A coding agent asked to add thumbnails adds a second subscription in the same TypeScript change and tests it with the same local run.

The database and Pub/Sub docs cover each declaration used here in more detail.

Best fit: teams moving off Render who want web services, workers, Postgres and file storage in their own AWS account with a deploy that is still a git push.

Staying on Render

Render is a strong choice when the app fits its service types, the team has no platform engineer, and nobody needs the data in a specific cloud account. Blueprints keep the setup in one file, preview environments make pull requests easy to review, and Render Postgres handles backups for you.

Best fit: small and mid-sized backends whose customers do not ask where the infrastructure runs.

AWS by Hand

The by-hand route is ECS on Fargate with an Application Load Balancer, RDS, SQS and SNS, S3, EventBridge Scheduler, Secrets Manager, and the IAM roles, security groups and VPC that connect them, written in Terraform or CDK with a CI pipeline for images. It gives a platform team full control.

Best fit: companies with platform engineers and existing infrastructure modules.

How to Choose

Stay on Render while its service types fit and where the infrastructure runs is not a requirement. Build on AWS by hand when a platform team is ready to own the infrastructure code. Pick Encore when you want the backend, its database, workers and storage in your own AWS account, declared in the same code you deploy.

Frequently asked questions

Is Render built on AWS?

No. Render does not run in your AWS account. Render runs your services on infrastructure it manages, in Render's accounts rather than yours, so a Render service cannot assume an IAM role in your AWS account or sit inside your VPC, and resources in your account are reached over the public internet.

Is Render cheaper than AWS?

Yes. For a small app, Render usually costs less in total once you count the time nobody spends on VPCs, IAM and load balancers. For a larger backend, the same CPU, memory and Postgres in your own AWS account usually cost less in cloud spend, and the gap has to be weighed against the engineering time AWS takes to set up.

What is the AWS equivalent of a Render background worker?

A Render background worker is a long-running process with no public port. On AWS, the usual equivalent is an ECS service on Fargate that reads from an SQS queue, with a dead-letter queue for messages that keep failing and a task role that allows it to receive and delete messages.

How do I move a backend from Render to my own AWS account?

Restore a pg_dump of Render Postgres into RDS, move uploaded files into S3, and run the web service and workers on ECS in the same account. With Encore, the database, bucket and queue are declared in TypeScript or Go, so a git push provisions RDS, S3 and SNS with SQS alongside the services.

Deploy to your cloud on AWS and Google Cloud
without managing infrastructure

Encore lets developers and agents define application infrastructure directly in code, then automatically provisions it from local development to production in your AWS or GCP account.

~/orders — claude
Claude Code
Claude Code v2.1.180Opus 5.5~/orders