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.

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.
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.
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.
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.
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.
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.
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.
Install the Encore CLI with the command for your system, then create the app:
Run in your terminal to get started locally.
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}`;
},
});
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.
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.
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.
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.
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.
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.
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.
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.