Render is the modern Heroku replacement: push a Git repo, and it builds and deploys web services, APIs, databases, static sites, workers, and cron jobs automatically. It surged in October 2022 when Heroku killed its free tier, and in 2026 it’s still one of the best free deals in hosting — if you know where the limits are.

Free tier at a glance

Render Free Tier: What You Actually Get

The 750-hour math: the 750 hours are granted to the workspace, not to each service, so a 24/7 service using ~720 hours/month effectively consumes the whole monthly allowance on its own — but free web services spin down after 15 minutes idle, waking on the next request. Free compute is capped at 0.1 CPU and 512MB RAM: fine for light workloads, not AI inference.

The Cold Start Reality

The number-one complaint, and it’s legitimate: Render puts the spin-up at about one minute. After 15+ minutes idle, the first request sits waiting while the container boots — a 50-second loading screen is bad UX for a public app. Workarounds:

• Scheduled pinger: a free cron service (e.g. cron-job.org) hitting your URL every 10 minutes keeps it warm. Note what this costs: Render grants 750 instance hours per workspace per month, so a service held awake around the clock burns roughly 720 of them by itself — the keep-warm trick works, but it spends nearly the entire monthly allowance on one service.
• No HTTP surface at all: a Telegram or Discord bot on long polling, or a queue consumer, never receives an inbound request, so it is idle from the moment it starts and the pinger advice above has no URL to point at. Render’s free plan also has no background workers to put it in. Both walls have one fix — see what to do about a free host that sleeps.
• Static + serverless: host the frontend as a Render static site (always on) and put dynamic endpoints on Cloudflare Workers or Vercel functions.
• Accept it: for internal tools, demos, and low-traffic APIs, cold starts are fine.
• Upgrade ($7/month): paid instances never spin down.
• Move it to a VPS: $7/month is also roughly two months of a small VPS, which gives you root, no spin-down and no instance-hour meter — at the cost of running the box yourself. Worth comparing before you upgrade in place; I wrote up the trade-off in this cheap VPS review.

Deploy a Python FastAPI App

Create a Web Service (New + → Web Service), connect the repo, pick a region and branch, set the runtime and commands, choose Free, and deploy. Render auto-detects most runtimes. A complete FastAPI example:

# main.py
from fastapi import FastAPI
from pydantic import BaseModel
import os

app = FastAPI(title="My Free API on Render")

class MessageRequest(BaseModel):
    text: str

@app.get("/")
def health_check():
    return {"status": "ok", "environment": os.environ.get("RENDER_ENV", "local")}

@app.post("/echo")
def echo(request: MessageRequest):
    return {"received": request.text, "length": len(request.text)}

# requirements.txt
fastapi==0.115.0
uvicorn[standard]==0.30.0

Render settings:

• Runtime: Python 3
• Build Command: pip install -r requirements.txt
• Start Command: uvicorn main:app --host 0.0.0.0 --port $PORT
• Plan: Free

Always use $PORT (Render injects it), never a hardcoded port. Your API goes live at https://your-service-name.onrender.com with automatic HTTPS. You can also commit a render.yaml to define the whole deployment as infrastructure-as-code and deploy it via New → Blueprint.

Node.js / Express

// server.js
const express = require('express');
const app = express();
app.use(express.json());

app.get('/', (req, res) => res.json({ status: 'ok', platform: 'Render' }));

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => console.log(`Server running on port ${PORT}`));

Render settings: Build Command npm install, Start Command npm start. Done.

Free PostgreSQL Database

One free PostgreSQL database per workspace: 1 GB storage, 100 concurrent connections. The catch: free databases expire 30 days after creation, after which they are inaccessible until upgraded, and Render deletes them once a 14-day grace period runs out. Render emails you before each deadline, but the migration is yours to handle. Connect from SQLAlchemy:

from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
import os

DATABASE_URL = os.environ["DATABASE_URL"]
# Render URLs start with postgres://, SQLAlchemy needs postgresql://
if DATABASE_URL.startswith("postgres://"):
    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql://", 1)

engine = create_engine(DATABASE_URL)
SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

Link the database to your service via the “Link a database” dropdown to set DATABASE_URL automatically. 30-day strategy: the free database expires 30 days after creation, then sits in a 14-day grace period before Render deletes it outright. Before expiry, pg_dump the data, make a new free DB, and pg_restore — about 10 minutes. For a permanent database, look at Neon or Supabase, whose free Postgres tiers don’t expire.

Static Sites: The Best Free Feature

Static hosting is the hidden gem of Render’s free tier, but be precise about what is unlimited: the number of sites, not the traffic they serve. You can deploy as many as you like with no spin-down and no cold start, on a global CDN, with automatic HTTPS, custom domains, auto-deploy on every push and PR preview deployments. Bandwidth, though, comes out of the same workspace pool as everything else — Render’s free-tier docs state that static sites count against your monthly included amounts, and the Hobby plan includes 5 GB, then $0.15 per extra GB. A static site and a web service share that 5 GB between them. It’s a real alternative to Netlify and Vercel; the only weakness is fewer CDN PoPs than Cloudflare. For a Next.js static export (output: 'export'), set Build Command npm install && npm run build and Publish Directory out.

Cron Jobs

Run scheduled scripts for cleanups, reports, and data syncs. Define one in render.yaml:

services:
  - type: cron
    name: daily-cleanup
    runtime: python
    buildCommand: pip install -r requirements.txt
    schedule: "0 2 * * *"   # 2 AM UTC daily
    startCommand: python cleanup.py

Cron jobs are not a free instance type. Render’s docs list only web services, Postgres, Key Value and static sites as free-eligible; everything else, cron included, is billed. Cron is metered per run from $1/month, so a schedule you expected to cost nothing will appear on the invoice.

Render vs Heroku vs Railway vs Fly.io

vs Heroku: Render wins outright — Heroku has no free tier and its $5 eco dynos still cold-start. vs Railway: Railway’s $5 credit is flexible but small (a web service plus DB burns it fast); Render is more generous for pure hosting hours, Railway edges ahead on DX and build speed. vs Fly.io: Fly gives always-on VMs (no cold starts) but demands Docker and a CLI-first workflow; Render is friendlier for beginners.

Practical Gotchas

• Ephemeral disk. The local filesystem isn’t persistent across deploys or spin-downs. Use Render PostgreSQL instead of SQLite, S3/R2/Supabase for uploads, and Redis for caching. Persistent Render Disks are a paid feature ($0.25/GB/month).
• Env vars & secrets. Set them in the dashboard, or use Environment Groups to share one set across multiple services. Secret Files handle things like service-account JSON.
• Custom domains & SSL are free on all plans — add a CNAME, and Render auto-provisions and renews a Let’s Encrypt cert.
• Health checks. Set a health-check path (e.g. /health) in Settings → Health & Alerts; Render restarts the service on non-200 responses.

Render vs Other Free Hosting

Render fills the gap between static-only platforms (Netlify, Cloudflare Pages) and Docker-first ones (Fly.io). For a Python, Node, Go, or Ruby app with zero-devops Git deployment, it’s the easiest path.

The Verdict

Render is the best free PaaS for developers in 2026: 750 instance hours per workspace, unlimited static sites, a 30-day PostgreSQL database and an in-memory Key Value store, with a Git-push-to-deploy workflow, automatic HTTPS, and per-PR previews. The cold-start limit is real for public apps, the database expires after 30 days, and anything that has to stay running — a worker, a scheduled job — is outside the free tier entirely — but for side projects, internal tools, prototypes, and learning, the free tier is more than capable. When you outgrow it, $7/month buys an always-on web service; ~$14/month (web + database) gets production-grade full-stack infrastructure with no ops overhead. Start free at render.com — no credit card required.