Railway vs Render: real pricing for a small app

One web service kept on, plus 1 GB of Postgres. Render's list price for that shape is $13.30. Railway Hobby is $19.65 if those sizes are held all month, and $7.65 if the CPU meter stays at zero.

By David · Published November 6, 2026 · Updated November 8, 2026 · 16 min read

Railway vs Render is a host choice for a small backend or web app. People also search render vs railway. It lives on the backend and stack hub. The reader wants a price, the free tier, the sleep rule, and what Postgres costs.

I did not deploy either host, and I did not open an invoice. Every dollar below is a reading of the vendor pages on November 6, 2026, or arithmetic on those rates. Where a page does not publish a figure, the cell says so.

Pricing compared

Railway pricing is a plan fee plus what the services actually use. The pricing page bills CPU, memory, and disk per second, and it prints a monthly constant next to each rate: $10 per GB of memory, $20 per vCPU, $0.15 per GB of volume, and $0.05 per GB of egress. Stopped services cost nothing. The plans page prints the same monthly prices, with per-minute rates beside them, and it says builds are free. The docs overview says the same monthly prices and describes billing by the minute. This post uses the monthly constants. A service you stop partway through the month costs less than the monthly line.

The plan fee is a credit toward that usage, not a second charge stacked on top of it. The plans page gives the Hobby examples. Usage of $3 bills $5, the subscription alone, because $3 is inside the $5 credit. Usage of $7 bills $7, which is the $5 subscription plus $2 over the credit. The overview page says usage of $8 bills $8 total. Pro is the same shape at $20: usage inside $20 bills $20, and usage past $20 bills the usage. The worked totals below follow that rule. They assume the Hobby fee is not waived. The plans page says Railway waives that fee for a small set of builders, picked automatically, and that asking for the waiver does nothing.

Render pricing is a workspace plan plus a compute plan you pick per service. On the pricing page, Hobby is $0 a month, Pro is $25, and Scale is $499. Compute is prorated to the second while the instance runs. The smallest paid web service on that page is plan 0.5c-512mb at $7 a month with 512 MB of RAM. The compute plans page says that plan is 0.5 CPU and 512 MB. The smallest paid Postgres plan on the pricing page is 0.1c-256mb at $6 a month with 256 MB of RAM and 100 connections. The compute plans page says that plan is 0.1 CPU and 256 MB, and that the compute plan does not set the disk size. Postgres storage on the pricing page is $0.30 per GB. Render’s own cost article, dated July 8, 2026, and still showing that $0.30 rate on November 6, says you add gigabytes times $0.30, and that you choose 1 GB or a multiple of 5 GB at creation. The pricing page does not print a number of gigabytes included at $0 on a paid database. This post bills the 1 GB at $0.30. If a paid plan includes that first gigabyte, the storage line is $0 and the Render total below is $13.00 instead of $13.30. I did not see that inclusion.

Hobby on Render includes 5 GB of bandwidth, then $0.15 per GB, and 500 build minutes, then $5 per 1,000 minutes. Two custom domains are included, then $0.25 each. None of those meters are in the $13.30.

The worked month

The app is one web service and one Postgres database. Both stay on for the whole billing month. Egress is zero in the arithmetic, which means the database is not reached through a public proxy and the app sends no outbound traffic in this total. No second replica. No high availability. No tax. Railway may add sales tax. The pricing FAQ says so, and this total does not.

On Render the sizes are the plans above, not a guess. The web service is 0.5c-512mb. The database is 0.1c-256mb plus 1 GB of storage. The workspace is Hobby.

On Railway the sizes are an illustration. Railway does not sell those boxes. The illustration holds the Render sizes on the meter for the whole month: 0.5 vCPU and 0.5 GB for the web service, 0.1 vCPU and 0.25 GB for Postgres, and a 1 GB volume. 256 MB is 0.25 GB, because 256 divided by 1,024 is 0.25. A quieter process costs less. The second Railway column sets CPU to zero and keeps the RAM and the disk, so you can see the floor. I did not measure a process. The idle-cost guide uses the same rates on a different footprint: 0.5 GB and 0.25 vCPU is about $10 for a month kept on. 0.5 times $10 is $5, and 0.25 times $20 is $5. That $10 is their example. It is not this app.

Check the two Railway bills against the plans-page rule before you trust them. $19.65 minus $5 is $14.65, and $5 plus $14.65 is $19.65. $7.65 minus $5 is $2.65, and $5 plus $2.65 is $7.65. Both are the “usage of $7 bills $7” case, not the “usage of $3 bills $5” case.

Render stays $13.30 in both readings. The $7 and the $6 are the price of the instance while it is running, not a share of a busy CPU. A paid Render service that you suspend is prorated. This total assumes you do not suspend it.

• $13.30

  Render, smallest paid web and Postgres, plus 1 GB

• $19.65

  Railway Hobby, those sizes held all month

• $7.65

  Railway Hobby, same RAM and disk, CPU at zero

• $5.00

  Railway Hobby minimum, even if usage is under $5

A Postgres plan with 1 GB of RAM, not 1 GB of disk, is a different Render line. Plan 0.5c-1g is $19 a month on the pricing page, with 1 GB of RAM and 100 connections. Storage is still extra. This post does not use $19. The defined app uses the smallest paid database, 256 MB of RAM, and 1 GB of disk.

Free tier and sleep limits

Render’s free web service is a real $0 instance, with a sleep rule. The free page says a Free web service spins down after 15 minutes without inbound traffic. Inbound means HTTP requests and WebSocket messages. The next request spins it back up, and that takes about a minute. Render shows a loading page while it starts. Spun-down time does not consume the 750 Free instance hours each workspace gets per calendar month. Hours do not roll over. When the 750 are gone, Free web services suspend until the next month. One Free web service that stays up all month still fits. 31 times 24 is 744 hours, and the grant is 750. Two services, both left running, do not fit.

The same page lists the other free-web limits that matter for a small app. The filesystem is ephemeral. A spin-down, a restart, or a redeploy drops local files, including a SQLite file. Free web services cannot attach a persistent disk. They cannot scale past one instance, and they cannot receive private-network traffic. They can send private-network requests to data stores in the same region. Render may restart a Free web service at any time. The compute plans page lists the free web plan as 0.1 CPU and 512 MB of RAM.

Railway does not publish that kind of idle timer for the Free plan. Services are long-running unless you turn Serverless on. The serverless reference, formerly called App-Sleeping, says inactivity is outbound packets, including database connections, telemetry, and NTP. After 5 minutes without those packets the service is inactive, and because the check is sampled, sleep lands between 5 and 10 minutes. The idle-cost guide says the toggle stops a service after 10 minutes of inactivity, and that a slept service accrues no compute. The first request wakes it. That request can return a 502. Enabling the toggle does not affect the container already running. You have to deploy again. The worked month leaves the toggle off, on both services.

The Railway Free plan is $0 with $1 of usage credit a month. The trial page says the credit does not roll over. A new account starts on a trial: $5 once, for 30 days, and then the account becomes Free. The pricing page caps a Free service at 1 vCPU and 0.5 GB, one replica, and a 0.5 GB volume. The platform table on that page also gives Free one project, three services, and zero custom domains. Hobby raises the volume cap to 5 GB and includes two custom domains.

Half a gigabyte held for a whole month, with no CPU and no disk, is 0.5 times $10, which is $5. The $1 credit is one fifth of that memory line. At the plans-page rate of $0.000231 per GB per minute, half a gigabyte is $0.0001155 a minute. $1 divided by $0.0001155 is 8,658 minutes, to the nearest minute, which is 144.3 hours. That is before any CPU. The Free plan allows up to 0.5 GB. It does not force the service to use 0.5 GB. A smaller footprint lasts longer. This is a reading of the rate, not a process I ran. The pages I read do not say the Free plan kills the service at the moment the $1 is spent. The pricing FAQ does list “usage limits reached” as a reason services stop, and the volume cap is a hard one: a 1 GB Postgres disk does not fit on Free.

Render Free Postgres is the mirror image on disk and the opposite on time. It is $0, 256 MB of RAM, and a fixed 1 GB of storage. A workspace can have one. It expires 30 days after creation. You then have 14 days to move it to a paid plan. After that, Render deletes it. Free databases have no backups and no managed connection pooling. Paying for the workspace, including Pro at $25, does not remove those limits. You change the database’s compute plan.

So the free tiers do not run this post’s always-on 1 GB shape for a month you can ignore. Render will sleep the free web service, and it will expire the free database. Railway Free cannot hold the 1 GB volume, and $1 of credit does not cover half a gigabyte of memory for the month.

Postgres on each

Railway Postgres is a service you add from the project canvas or from the template marketplace. The Postgres page says the image is Railway’s SSL-enabled build on the official Postgres image, and that the service exposes DATABASE_URL plus the usual PGHOST, PGPORT, PGUSER, PGPASSWORD, and PGDATABASE variables. It is private by default. Public access is a TCP proxy, and the page says you are billed for network egress when you use that proxy. The worked month assumes you do not. High availability, backups, and connection pooling are separate steps on that page. They are not in the $19.65 or the $7.65.

The disk is a volume at $0.15 per GB-month. Hobby allows 5 GB. The 1 GB in this post fits on Hobby and does not fit on Free or on the trial, which the plans page also caps at 0.5 GB of volume.

Render Postgres is a managed database with its own plan ids. You pick compute and storage separately. The create docs say the initial disk is 1 GB or any multiple of 5 GB, you can increase it later, and you cannot decrease it. Storage autoscaling, if you turn it on, adds capacity when the disk is getting full, and that increase is also permanent. The $0.30 rate is per GB-month, prorated to the second, on the cost article. A 1 GB disk is the smallest size that page and the create docs name.

The $6 plan is the smallest paid database. It does not expire in 30 days. The free database does, and it is already 1 GB, so the reason to pay $6 is the expiry, the backups, and the fact that a paid instance stays up. The pricing page says logical exports are for paid instances. The free page says free databases do not support any backups.

If the thing you actually want is hosted Postgres that can suspend, and the app can live somewhere else, that comparison is Neon vs Supabase. Neon suspends compute. Supabase Free pauses a quiet project after a week. Neither number is a Railway volume or a Render instance. If the database is still one file on one machine, the local timings are SQLite vs Postgres. This post did not run those queries.

Deploy experience

Render’s pricing page puts “Connect your repo, and go” on the Hobby workspace. The free docs walk the dashboard path: New, then Web Service or Postgres, then a compute plan, including Free. A paid web service does not spin down on idle. The cost article says paid instances run until you suspend them. Free web services do spin down, and a free database still expires on day 30 even if the web service is paid. The pricing page also lists a render.yaml blueprint for infrastructure as code. I did not connect a repo, and I did not time a build. The 500 included pipeline minutes are a workspace meter, not a number from a deploy I ran.

Railway’s Postgres page is the deploy step I can actually cite: add the database on the canvas, read DATABASE_URL, and leave it private unless you need the TCP proxy. The plans page says service builds are free, including build CPU and memory. Serverless, if you want the sleep, is a per-service toggle under Settings, then Deploy, and it applies on the next deployment. The idle-cost guide says a database is a bad fit for that toggle, because open connections count as outbound traffic and the service never sleeps. I did not click through a Git deploy on Railway, so this page does not time one and does not name a Git button I did not see.

What I can say from the pages, for a small app, is the day-to-day difference. On Render you pick a box and the bill is that box. On Railway you pick a plan, the services run, and the bill is whatever CPU and memory they held. Custom domains are included on a Render Free web service. Railway Free lists zero custom domains, and Hobby lists two. Logs on the Railway pricing page are 3 days on Free and 7 days on Hobby. Render’s pricing table lists 7 days of log retention on Hobby.

The other deploy choice, when the app is a Worker or a static site rather than a long-running process, is Cloudflare Workers or Pages. That post does not price Railway or Render. This one does not price Workers. The frontend version of this choice, Vercel or Netlify, is priced from the vendor pages, with a TTFB check.

When to pick which

The $13.30, the $19.65, and the $7.65 are the decision on this page. They leave out egress, build overages, tax, and any CPU the Railway services use beyond the column you picked. Run the app for a week and read the usage screen before you treat $19.65 as your invoice. Railway’s own pricing FAQ says they cannot quote a workload they have not metered. That is the right caution. The arithmetic is still checkable, because every rate in it is on the pages linked below.