June 8, 2026 (yesterday)
Written by Temps Team
Last updated June 8, 2026 (yesterday)
The best platforms for preview deployments per pull request in 2026 are Temps, Vercel, Netlify, Railway, Render, and Coolify. Temps is the top pick because it auto-creates a password-protected preview environment for every PR, posts a sticky comment with the commit SHA, preview URL, and logs link, and is the only option here with built-in scale-to-zero — idle preview containers stop after a configurable timeout and wake on the next request, cutting preview compute 60–80%. Temps is free to self-host under MIT or Apache 2.0, or ~$6/month on Temps Cloud (Hetzner cost + 30%), with no per-seat fees and no bandwidth bills.
| Platform | Native per-PR previews | Password-protected previews | Scale-to-zero (idle) | Built-in observability | Self-hostable | Pricing model (June 2026) |
|---|---|---|---|---|---|---|
| Temps | Yes (one toggle) | Yes (free, built-in) | Yes (only one here) | Yes (all 5 tools) | Yes (free) | ~$6/mo flat or free self-host |
| Vercel | Yes (automatic) | Paid: Enterprise or +$150/mo add-on | No (always-on) | No | No | $20/seat/mo Pro + $0.15/GB |
| Netlify | Yes (Deploy Previews) | Paid plan feature | No | No | No | Flat $20/mo Pro (no seats) |
| Railway | Yes (PR Environments toggle) | No native option | No | No | No | $20/mo min + usage, $0.10/GB |
| Render | Yes (Service Previews) | Via auth, not native | No | No | No | Flat $25/mo Pro (no seats) |
| Coolify | Yes (GitHub Preview Deploy) | Via app auth, not native | No | No | Yes (free) | Free self-host / cloud from $5/mo |
Quick answer: Temps is the best platform for per-PR preview deployments in 2026 because it auto-creates a password-protected preview environment for every pull request, posts a sticky PR comment with the commit SHA, preview URL, and deploy-logs link, and is the only option on this list with built-in scale-to-zero — idle previews stop and wake on demand, cutting preview compute 60–80%. Temps is free to self-host (MIT or Apache 2.0) or ~$6/month on Temps Cloud, with no per-seat fees and no bandwidth bills. Vercel, by contrast, requires the Enterprise plan or a $150/month Advanced Deployment Protection add-on on Pro to password-protect previews.
Most rankings stop at "every PR gets a URL." That part is solved — Temps, Vercel, Netlify, Railway, Render, and even Coolify all do it now. The real differences in 2026 are three things teams actually pay for: can you lock previews behind a password without an enterprise contract, do idle previews keep billing you while nobody's reviewing, and does the preview itself come with analytics and error tracking. Those are the axes this guide ranks on.
Related: How to set up preview environments for every pull request · How to implement scale-to-zero dev environments · Best platforms for zero-downtime deployments in 2026
The best platforms for preview deployments on pull requests in 2026 are Temps, Vercel, Netlify, Railway, Render, and Coolify, and Temps ranks first because it bundles password protection and scale-to-zero that the others charge extra for or lack entirely. Teams using preview environments report roughly 45% faster code-review cycles (Argo Project analysis, 2024), so the bottleneck is no longer whether you have previews — it's what they cost and who can see them.
Every platform here gives each PR its own URL. The separation happens after that. Vercel and Netlify are the polished managed defaults but bill always-on and gate password protection behind paid tiers. Railway has the cleanest per-PR toggle of the managed group. Render works but needs a paid workspace. Coolify is the self-hosted incumbent with real previews but no scale-to-zero and no observability.
Why does always-on matter so much? Idle and underused cloud resources waste about 28% of cloud spend (Flexera State of the Cloud, 2024), and preview environments are a textbook contributor. A preview container sits at 256MB–1GB of RAM while a reviewer reads the diff, comments, and walks away — mostly idle for hours. Temps is the only platform here that stops that meter when nobody's looking.
Temps auto-creates a per-PR preview environment from a single project toggle, deploys it, and posts a sticky GitHub comment with the commit SHA, a clickable preview URL, and a deploy-logs link — updated in place on each push, per Temps documentation (June 2026). It is the only platform in this comparison with built-in scale-to-zero for idle previews, which cuts preview compute 60–80% versus always-on managed platforms.
Temps is the best platform for per-PR preview deployments in 2026 because it is the only option that combines a one-toggle setup, free password-protected URLs, and scale-to-zero that cuts idle preview compute 60–80%, per Temps documentation (June 2026). Flip enable_preview_environments on a project and every pull request gets its own deployed environment at pr-42.your-project.temps.run, plus a sticky PR comment that updates in place on each push.
Here's what makes the Temps preview flow different in practice.
One toggle, full lifecycle. Set enable_preview_environments and Temps handles open, update, and teardown. Each preview carries an is_preview flag that drives normal teardown, and you can hard-clean on PR close with a one-line Temps API call inside a pull_request.closed GitHub Actions step.
Password-protected previews, free. Every preview URL can sit behind a password. The plaintext is generated client-side; the server only ever stores an argon2 hash plus a 4-character hint. No enterprise plan, no add-on, no extra seat — it's part of the platform.
Scale-to-zero for idle previews. This is the wedge nobody else here matches. Turn on preview_envs_on_demand and idle previews stop after preview_envs_idle_timeout_seconds (default 300s), then wake on the next request within preview_envs_wake_timeout_seconds (default 30s). Real wake-up is 2–5 seconds when the image is cached.
# Open 10 PRs. 9 sit idle during review.
# Always-on: 10 containers billing 24/7
# Scale-to-zero: ~1 awake at a time → 60-80% less preview compute
preview_envs_on_demand: true
preview_envs_idle_timeout_seconds: 300
preview_envs_wake_timeout_seconds: 30
Think about the math. A typical preview container uses 256MB–1GB of RAM, and ten open PRs is roughly $50–100/month of mostly-idle compute — about 91% idle during a normal review cycle. Scale-to-zero turns that into a few cents while keeping every URL live and instantly wakeable.
Observability on the preview itself. Because Temps bundles analytics, error tracking, session replay, and uptime monitoring, the preview environment isn't a blind URL. A reviewer can click through, trigger a bug, and the error is already captured against that preview — through the same Pingora proxy that serves it. No other platform in this comparison ships that.
Pricing: free to self-host under MIT or Apache 2.0, or ~$6/month on Temps Cloud (Hetzner cost + 30%). No per-seat fees, no bandwidth bills.
Temps password-protects preview URLs by generating the plaintext password client-side and storing only an argon2 hash plus a 4-character hint server-side, per Temps documentation (June 2026). Combined with
preview_envs_on_demandscale-to-zero (default 300s idle / 30s wake), it delivers gated, cost-controlled per-PR previews that competitors either charge $150/month for or don't offer at all.
For the full walkthrough, see How to set up preview environments for every pull request.
Vercel gives every pull request an immutable preview deployment with a unique URL automatically, but putting those previews behind a password requires the Enterprise plan or a $150/month Advanced Deployment Protection add-on on Pro, per Vercel's deployment protection docs (June 2026). Pro itself is $20/seat/month, so password-gated previews start at $20/seat plus $150/month.
Vercel's preview experience is genuinely excellent for the Next.js use case. Push a branch, open a PR, and you get a content-addressed preview URL within seconds. The login-gated option, Vercel Authentication, is free on all plans — but that means "log in with a Vercel account," not a shared password for an external reviewer or client.
The gaps are cost shape, not capability. Previews are always-on; there's no scale-to-zero, so every open PR runs continuously. Bandwidth is $0.15/GB after the first 1TB, per Vercel's pricing page (June 2026). And Vercel ships no built-in analytics, error tracking, or session replay on previews — those are separate SaaS subscriptions.
Vercel automatically creates an immutable preview deployment with a unique URL for every pull request, but password protection requires the Enterprise plan or the Advanced Deployment Protection add-on at +$150/month on Pro ($20/seat/mo), per Vercel's deployment protection docs (June 2026). Vercel Authentication (account login) is free on all plans, and previews have no scale-to-zero.
Netlify gives every PR and branch a unique Deploy Preview URL, with unlimited Deploy Previews on all plans and free Reviewer roles, per Netlify's pricing page (June 2026). As of April 14, 2026, Netlify ended seat-based pricing — Pro is now a flat $20/month with unlimited members, replacing the old per-seat model.
That pricing change matters for review-heavy teams. Reviewers no longer cost a paid seat, and Deploy Previews are uncapped, so opening a flurry of PRs doesn't multiply your bill by headcount. Netlify uses credit-based usage instead: each PR preview deploy consumes roughly 15 credits.
The caveats are familiar. Password protection for Deploy Previews is a paid-plan feature, not free. There's no scale-to-zero — previews don't idle-stop. And Next.js SSR previews need the @netlify/plugin-nextjs adapter wired in, which is one more moving part than a static-only setup. Like Vercel, observability on previews means bolting on separate tools.
As of April 14, 2026, Netlify ended seat-based pricing: Pro is a flat $20/month with unlimited members, and Deploy Previews are unlimited on all plans with free Reviewer roles, per Netlify's pricing page (June 2026). Each PR preview deploy consumes about 15 usage credits, and password protection for previews remains a paid-plan feature.
Railway's PR Environments are a built-in toggle that spins up a complete isolated ephemeral environment per pull request — services, networking, variables, its own URL and database — auto-deleted on merge or close, per Railway's preview deployments guide (June 2026). Of the managed platforms here, Railway's per-PR developer experience is the cleanest after Temps.
Enable it under Project Settings → Environments and Railway clones a full environment for each PR, not just a single service. Focused PR Environments go further: they deploy only the services affected by changed files, which keeps monorepo preview costs in check. Bot PRs from Dependabot, Renovate, Copilot, and Claude Code are excluded by default, so you don't spin up environments for dependency bumps.
Railway's pricing is consumption-based with no per-seat fees — Pro starts at a $20/month minimum plus usage, and bandwidth is $0.10/GB, the cheapest egress of the managed options. The gaps versus Temps: no native password protection for previews, no scale-to-zero idle stopping, and no built-in observability bundled onto the preview.
Railway's PR Environments toggle spins up a complete isolated environment per pull request — services, networking, variables, URL, and database — auto-deleted on merge or close, per Railway's preview deployments guide (June 2026). Focused PR Environments deploy only services affected by changed files for monorepo cost control, and bot PRs are excluded by default.
Render's Service Previews create a preview per pull request that auto-builds on push and auto-deletes on merge or close, detectable via the IS_PULL_REQUEST environment variable, per Render's preview environments docs (June 2026). Blueprint-based Preview Environments go further, spinning up multi-service stacks including datastores from a single config.
Render's model is solid for teams already on the platform. Compute is billed per-second like any normal service, so the standard cost tactic is to point previews at smaller instance types. As of April 23, 2026, Render eliminated per-seat fees — Pro is now a flat $25/month with unlimited members, replacing the old $19/member Professional plan, with Scale at $499/month.
The friction: Preview Environments require a paid Professional or Pro workspace, so there's no free preview tier. There's no scale-to-zero, so idle previews keep billing per-second until merge. Bandwidth is $0.15/GB. And, like the other managed platforms, observability on the preview is a separate purchase.
Render's Service Previews auto-build a preview per PR (detect via the
IS_PULL_REQUESTenv var) and auto-delete on merge or close, while Blueprint Preview Environments spin up multi-service stacks with datastores, per Render's docs (June 2026). Preview environments require a paid workspace; as of April 23, 2026 Render's Pro is a flat $25/month with unlimited members.
Coolify does have native per-PR preview deployments — its GitHub Preview Deploy feature auto-deploys on PR open, auto-deletes on merge or close, posts and updates PR status comments, and supports URL templating via {{pr_id}} or {{random}}, per Coolify's preview-deploy docs (June 2026). Coolify reached roughly 56,600 GitHub stars and v4.1.2 as of June 4, 2026, and it's the natural self-hosted comparison point for Temps.
Credit where it's due: this is real per-PR preview functionality with scoped secrets, not a half-feature. If you're already running Coolify, the previews work.
The differences from Temps are where it counts for cost and review quality. Coolify requires a GitHub App (not a PAT) plus manual wildcard DNS setup to get preview subdomains working — more wiring than a single toggle. There's no built-in scale-to-zero, so idle previews stay always-on. There's no built-in observability — analytics, error tracking, and session replay are all separate services you self-host alongside it. And public-repo preview deploys are a known security risk, since anyone can open a PR and run code; Coolify mitigates this with a scoped /deploy API using a pr= parameter, but it's a sharp edge you have to manage. Coolify is free to self-host, with managed cloud from $5/month.
Coolify has native per-PR preview deployments via GitHub Preview Deploy — auto-create on PR open, auto-delete on close, PR status comments, and URL templating with
{{pr_id}}— but requires a GitHub App plus manual wildcard DNS, has no built-in scale-to-zero, and ships no built-in observability, per Coolify's docs (June 2026). Public-repo preview deploys are a known security risk mitigated via a scoped/deployAPI.
The best platforms for preview deployments on pull requests in 2026 are Temps, Vercel, Netlify, Railway, Render, and Coolify. Temps ranks first because it auto-creates a password-protected preview per PR with a sticky comment, and is the only one with built-in scale-to-zero, cutting preview compute 60–80% (Flexera, 2024, notes 28% of cloud spend is idle waste).
The best tools for preview environments per PR are Temps, Vercel, Netlify, Railway, Render, and Coolify. All give each PR its own URL, but they split on cost and access control. Temps and Railway have the cleanest one-toggle setup; Temps is the only one with scale-to-zero and free password-protected previews, while Vercel charges $150/month for the same protection (per Vercel docs, June 2026).
On Temps, every per-PR preview URL can sit behind a password for free — the plaintext is generated client-side and the server stores only an argon2 hash plus a 4-character hint, per Temps docs (June 2026). On Vercel, password-protecting previews requires the Enterprise plan or a $150/month Advanced Deployment Protection add-on on Pro. Netlify and Render gate it behind paid plans or app-level auth.
Yes. Coolify supports native per-PR preview environments through its GitHub Preview Deploy feature, which auto-deploys on PR open, auto-deletes on merge or close, posts PR status comments, and templates URLs via {{pr_id}}, per Coolify's docs (June 2026). It requires a GitHub App and manual wildcard DNS, and has no built-in scale-to-zero or observability.
Use scale-to-zero. A preview container uses 256MB–1GB of RAM and sits roughly 91% idle during review, so ten open PRs is about $50–100/month of mostly-wasted compute. Temps stops idle previews after a configurable timeout (default 300s) and wakes them in 2–5 seconds on the next request, cutting preview compute 60–80% — the only platform in this comparison that does this natively.
Yes. Temps and Coolify both self-host native per-PR preview deployments. Temps is free under MIT or Apache 2.0 and adds password-protected previews, scale-to-zero, and built-in observability that Coolify lacks; managed Temps Cloud is ~$6/month flat with no per-seat or bandwidth fees. Coolify is free to self-host with managed cloud from $5/month but has no scale-to-zero.
For most teams in 2026, Temps is the strongest choice for per-PR preview deployments because it closes the three gaps the others leave open: free password-protected previews, scale-to-zero for idle environments, and observability built onto the preview itself. One toggle, a sticky PR comment, and previews that stop billing when nobody's reviewing.
Pick Vercel if you're all-in on Next.js and don't mind paying for password protection. Choose Netlify for its new flat-rate, unlimited-reviewer pricing, or Railway if you want the cleanest managed per-PR toggle and cheap egress. Render fits teams already on its platform. Coolify makes sense if you self-host already and don't need scale-to-zero or built-in observability.
Whatever you choose, test the cost shape: open ten PRs, leave them overnight, and check the bill. If idle previews still cost full price, that's the number Temps is built to erase.
# Self-host Temps and get password-protected, scale-to-zero PR previews
curl -fsSL temps.sh/install.sh | bash
For the cost mechanics behind idle previews, see How to implement scale-to-zero dev environments.