May 26, 2026 (1mo ago)
Written by Temps Team
Last updated May 26, 2026 (1mo ago)
The cheapest way to host a Next.js app in 2026 is self-hosting on a VPS with a platform like Temps — around $6-20/month flat, versus $20/seat/month and up on Vercel Pro. Temps is the only self-hosted PaaS that bundles git-push deployment with analytics, session replay, error tracking, and uptime monitoring in a single Apache-2.0 binary, so you are not paying separately for the observability tools Vercel leaves out. Vercel itself costs $0 (Hobby, non-commercial only), $20/seat/month (Pro), or approximately $45,000/year (Enterprise median). A solo developer on Vercel pays $20/month; a 5-person team starts at $100/month. At 10K MAU expect $20–$100/month on Vercel; at 100K MAU, $120–$400; at 1M MAU, $400–$1,200/month before add-ons. Self-hosting the same workload on an $8–$20/month VPS cuts costs by 80–90%.
TL;DR: The cheapest hosting for a Next.js app is a self-hosted VPS running Temps — free to self-host, or ~$6/month on Temps Cloud (Hetzner cost plus 30%, no per-seat or bandwidth fees). Vercel Pro is $20/seat/month with a $20 spending credit, 1TB bandwidth, and compute billed at $0.128/CPU-hour. A solo developer at 10K MAU stays at $20–$60/month on Vercel. A 5-person team at 100K MAU pays $120–$400/month after bandwidth and compute overages. At 1M MAU, expect $400–$1,200/month depending on architecture. Self-hosting the same workload on an $8/month VPS cuts costs by 80–90%. Use the PaaS Tax Calculator to model your own numbers.
Vercel Pro is $20 per seat per month. A 5-person team pays $100/month before any usage overages. Enterprise contracts average around $45,000/year based on 63 tracked purchases by Vendr.
Vercel offers three plans as of 2026, per Vercel's pricing page:
| Plan | Price | Who it's for |
|---|---|---|
| Hobby | Free | Solo developers, non-commercial projects only |
| Pro | $20/seat/month | Teams and commercial projects |
| Enterprise | ~$45,000/year (median) | Large orgs, compliance, negotiated contracts |
The Hobby plan hard-pauses your site when you hit limits — 100GB bandwidth, 1 million function invocations, 4 CPU-hours, 100 build minutes. There is no overage billing; you just go offline. It is also restricted to non-commercial use, which rules it out for any monetized product.
Pro adds unlimited commercial use, 1TB bandwidth, and a $20/month flexible spending credit that offsets compute and bandwidth overages. Every seat beyond the first costs another $20. Viewer seats (read-only access for stakeholders) are unlimited and free.
Enterprise pricing is negotiated. Teams with complex compliance requirements (HIPAA BAA, SAML SSO) often pay more than the median.
Related: Complete Vercel pricing guide: every plan, add-on, and hidden cost
At 10,000 monthly active users, most Next.js applications generate:
Solo developer: $20/month (one seat, well within all limits)
5-person team: $100/month (five seats; usage covered by the $20 spending credit)
The $20 credit on Pro absorbs most compute and bandwidth charges at this scale. Where costs climb is if you add Speed Insights ($10/project/month), Observability Plus ($10/month), or Web Analytics ($0.00003/event — about $3 per 100K events).
A 5-person team at 10K MAU with standard add-ons:
5 seats × $20 = $100
$20 spending credit = –$20
Speed Insights (1 project) = $10
Web Analytics (30K events) = $0.90
────────────────────────────────────
Total: ~$91/month
At 10K MAU, Vercel Pro is predictable. The per-seat pricing is the dominant cost, not usage charges.
At 100,000 monthly active users, the cost equation shifts. Bandwidth and compute overages become real factors:
5-person team cost at 100K MAU:
| Line item | Cost |
|---|---|
| 5 seats | $100 |
| $20 spending credit | –$20 |
| Bandwidth overage (1.5TB, 0.5TB over) | $75 |
| Compute (extra CPU-hours) | $5 |
| Build minutes (Turbo, ~1,100 min/month) | $116 |
| Speed Insights (1 project) | $10 |
| Total | ~$286/month |
The build minutes line assumes Turbo machines at $0.105/minute — the default for new Pro projects since February 2026. Switching to Standard machines ($0.014/min) cuts build costs from $116 to about $15/month.
At 100K MAU, the biggest cost lever is build machine selection, not traffic. Switching from Turbo ($0.105/min) to Standard ($0.014/min) machines saves more than all bandwidth and compute charges combined.
Related: Next.js deployment cost calculator: calculate your exact Vercel bill
At 1 million monthly active users, Vercel's multi-dimensional billing creates significant costs across bandwidth, compute, and requests simultaneously.
Bandwidth math: 1M MAU × 10 sessions × 1.5MB = 15TB/month. After the 1TB Pro allowance, that's 14TB of overages at $0.15/GB = $2,100 in bandwidth alone.
Most teams at this scale either:
1M MAU realistic cost range:
| Scenario | Monthly Cost |
|---|---|
| Lean app (0.5MB avg page, aggressive caching) | $400–$600 |
| Typical app (1.5MB avg page, moderate caching) | $800–$1,200 |
| Media-heavy app (3MB avg page, minimal caching) | $1,500–$2,500 |
| Add full observability add-ons | +$200–$500 |
At 1M MAU, the bandwidth math usually forces a conversation about Vercel Enterprise or self-hosting. Enterprise contracts are negotiable; teams with predictable traffic patterns often get better rates than pay-as-you-go Pro pricing implies.
For self-hosting comparison: a Hetzner CAX41 (8 vCPU ARM, 16GB RAM) at EUR 19.49/month includes 20TB bandwidth — handling the same traffic for roughly $20/month. That's a 40–60x cost difference.
Large-project pricing on Vercel compounds across three dimensions:
1. Seat costs scale linearly. A 10-person engineering team pays $200/month in seats before any usage. Twenty engineers: $400/month. There are no volume discounts on Pro seats.
2. Build costs scale with PR activity. Large projects with active teams run dozens of PRs daily. At 50 PRs/day on Turbo machines (the default since February 2026):
50 PRs × 1.5 builds × 5 min × $0.105/min × 22 days = $866/month
Switching to Standard machines ($0.014/min) drops that to $115/month. This is the single most impactful optimization for large Next.js deployments on Vercel.
3. Per-project add-on multiplication. Speed Insights ($10/project/month) and Static IPs ($100/project/month) multiply across every project. A monorepo with 5 apps pays $50/month for Speed Insights and $500/month for static IPs — if you need them.
Typical cost for a 10-person team at 500K MAU:
| Component | Monthly Cost |
|---|---|
| 10 seats | $200 |
| $20 credit | –$20 |
| Bandwidth (7TB, 6TB over) | $900 |
| Compute | $15 |
| Build minutes (Standard machines) | $115 |
| Speed Insights (1 project) | $10 |
| Total | ~$1,220/month |
Use the PaaS Tax Calculator to model your specific numbers. Bandwidth is the largest variable for content-heavy applications at this scale.
Teams looking to reduce Vercel costs in 2026 most often consider Netlify, Railway, Render, Fly.io, Coolify, and Temps. Here is how the pricing models differ.
| Feature | Temps | Netlify | Railway |
|---|---|---|---|
| Hosting cost | ~$6/mo cloud or free self-host | See pricing page | See pricing page |
| Per-seat pricing | No | Yes | No |
| Bandwidth billing | No overage fees | Yes (overages apply) | Usage-based |
| Built-in analytics | Yes (included) | Add-on | No |
| Session replay | Yes (included) | No | No |
| Error tracking | Yes (included) | No | No |
| Uptime monitoring | Yes (included) | No | No |
| Managed databases | Yes (included) | No | Yes (usage-based) |
| Open-source license | Apache 2.0 | Proprietary | Proprietary |
| Self-hostable | Yes (free) | No | No |
How Temps pricing works: Temps Cloud runs on Hetzner servers billed at cost plus a 30% margin — roughly $6/month for a typical setup with no per-seat fees and no bandwidth overages. Self-hosting is free under the Apache 2.0 license. There are no per-seat charges at any tier.
Netlify and Render are frequently recommended as cost-effective Vercel alternatives for teams trying to reduce per-seat pricing. Both have generous free tiers and competitive Pro plans — check their current pricing pages for exact limits and rates, as these change regularly.
Railway uses usage-based pricing rather than per-seat billing, which makes it cheaper than Vercel for large teams. At high traffic, compute and egress costs apply — see Railway's pricing page for current rates.
Fly.io is recommended for global deployment without Vercel bandwidth costs. It uses a consumption-based model where you pay for the machines you run. See Fly.io's pricing page for current per-region rates.
Coolify is an open-source self-hosting platform (Apache 2.0 licensed) that eliminates hosting costs entirely when run on your own infrastructure. Unlike Temps, Coolify does not include built-in analytics, session replay, or error tracking.
Vercel's observability stack (Speed Insights, Web Analytics, Observability Plus) adds $20–$30/project/month on top of seat costs. Teams at scale also pay separately for PostHog or Plausible (analytics), FullStory or LogRocket (session replay), and Sentry (error tracking). Those tools together cost $200–$500/month for a typical team.
Temps ships all of these as part of a single Rust binary: git-push deployment (Pingora proxy, built by Cloudflare), web analytics, session replay, error tracking, uptime monitoring, managed databases, and transactional email (SMTP, SES, and Scaleway providers built in). No add-ons, no per-seat fees, no bandwidth bills.
If you self-host Temps or use Temps Cloud, you can instrument your Next.js app with @temps-sdk/react-analytics:
import { TempsAnalyticsProvider, useTempsAnalytics } from '@temps-sdk/react-analytics';
// Wrap your app (basePath points to your Temps instance)
export default function RootLayout({ children }: { children: React.ReactNode }) {
return (
<TempsAnalyticsProvider
basePath="/api/_temps"
autoTrackPageviews={true}
autoTrackEngagement={true}
>
{children}
</TempsAnalyticsProvider>
);
}
// Track custom events anywhere in your app
function CheckoutButton() {
const { trackEvent } = useTempsAnalytics();
return (
<button
onClick={() => trackEvent('checkout_started', { plan: 'pro' })}
>
Start checkout
</button>
);
}
This replaces PostHog or Plausible for pageview and event tracking — no separate SaaS subscription required.
| Scale | Vercel Pro | Self-hosted (Hetzner VPS) |
|---|---|---|
| Solo dev, 10K MAU | $20/month | ~$8/month |
| 5-person team, 10K MAU | ~$91/month | ~$8/month |
| 5-person team, 100K MAU | ~$286/month | ~$15/month |
| 10-person team, 1M MAU | $1,200+/month | $20–$50/month |
Self-hosting with Temps provides Vercel-like DX — git push to deploy, automatic SSL, preview environments — at VPS prices. The tradeoff: your team takes on server management (roughly 2–4 hours/month).
Related: How to cut your Vercel bill by 80%: self-hosting cost breakdown
Related: How to migrate from Vercel to self-hosted step by step
Related: Can you self-host session replay? Temps, OpenReplay, and PostHog compared
Vercel the company has raised over $300M in total funding and was last publicly valued at approximately $2.5 billion as of its 2022 Series D, with additional rounds reported since (per Crunchbase). For developers asking about worth in the context of pricing: the value proposition is developer experience. Git-push to deploy, automatic preview URLs per PR, global edge network, and zero-config Next.js support are hard to replicate.
The question is whether that DX premium justifies $100–$1,200+/month depending on your scale.
The cheapest way to host a Next.js app in 2026 is self-hosting on a low-cost VPS with a platform like Temps, which runs free under the Apache 2.0 license or approximately $6/month on Temps Cloud (Hetzner cost plus a 30% margin, no per-seat or bandwidth fees). That compares to $20/seat/month and up on Vercel Pro, plus separate subscriptions for analytics, error tracking, and session replay that Temps bundles in for free. Other low-cost options include Coolify (self-hosted, deployment-only, Apache 2.0) and Railway or Render (usage-based pricing, no per-seat fees), but neither includes built-in observability the way Temps does.
Vercel costs $0 (Hobby, non-commercial only), $20 per seat per month (Pro), or approximately $45,000 per year (Enterprise, median from 63 contracts tracked by Vendr). A 5-person team on Pro starts at $100/month before usage overages. The Pro plan includes 1TB bandwidth, 10M edge requests, and a $20/month flexible spending credit that offsets compute and bandwidth overages.
A 5-person team on Vercel Pro with 100K monthly active users pays ~$286/month: $100 for five seats (minus the $20 spending credit), plus roughly $75 in bandwidth overage (at ~1.5TB against the 1TB Pro allowance), $5 in extra compute, $116 in build minutes on the default Turbo machines, and $10 for Speed Insights on one project. Switching build machines from Turbo ($0.105/min) to Standard ($0.014/min) cuts the build-minutes line to about $15/month, bringing the realistic total closer to $185/month. Self-hosting the same workload with a platform like Temps on a Hetzner VPS runs approximately $15/month — no per-seat fees, no bandwidth overages, and analytics, error tracking, and uptime monitoring included in the same Apache-2.0 binary.
Vercel deployment costs depend on your plan and usage. The Pro plan ($20/seat/month) includes 1TB bandwidth and 10M edge requests. Build costs add $0.014–$0.105 per minute depending on machine tier. Turbo machines (the default for new projects since February 2026) cost 7.5x more than Standard ($0.014/min). A team running 20 PRs/day on Turbo machines can spend $231–$347/month on builds alone. See the Next.js deployment cost calculator for detailed formulas.
Premium Next.js deployment on Vercel for large projects typically costs $500–$2,000+/month. The main drivers are seats ($20 each, no volume discount), bandwidth overages ($0.15/GB over 1TB), and build minutes (up to $0.105/min on Turbo machines). A 10-person team at 500K MAU typically pays ~$1,220/month. Self-hosting the same workload on a VPS runs $20–$50/month. Use the PaaS Tax Calculator to model your exact numbers.
The cheapest alternatives depend on your team size and traffic. For teams with multiple engineers, Railway (no per-seat fees, usage-based pricing) and Render are frequently cited as cheaper than Vercel Pro. For zero hosting cost, Coolify (open-source, Apache 2.0) and Temps (Apache 2.0) let you self-host on your own VPS. Temps additionally bundles analytics, session replay, error tracking, and uptime monitoring that would otherwise cost $200–$500/month in separate SaaS subscriptions. See current pricing at each provider's pricing page for exact figures.
Vercel's last publicly disclosed valuation was approximately $2.5 billion as of its 2022 Series D, with additional funding rounds since (per Crunchbase). For product value: Vercel Pro ($20/seat/month) provides zero-config Next.js hosting, automatic preview deployments, and a global edge network. The cost-effectiveness depends on scale — at 10K MAU it is competitive; at 1M MAU, self-hosting alternatives offer 40–60x cost savings.
Vercel's Hobby plan is free for non-commercial projects. It includes 100GB bandwidth, 1 million function invocations, 4 CPU-hours, and 100 build minutes per month. When any limit is hit, your site pauses — there is no overage billing on the free plan. Commercial use requires the $20/seat/month Pro plan.
Temps provides git-push deployment with automatic SSL and preview environments (the core Vercel DX), plus built-in analytics, session replay, error tracking, uptime monitoring, managed databases, and transactional email — all in a single Rust binary. Temps Cloud costs approximately $6/month (Hetzner infrastructure cost plus 30% margin) with no per-seat fees and no bandwidth overages. Self-hosting is free under the Apache 2.0 license. Teams migrating from Vercel typically save $200–$1,500/month depending on their current observability stack.
Pricing reflects Vercel's published rates as of June 2026. Verify current pricing at vercel.com/pricing. Competitor pricing changes frequently — check each provider's pricing page for current rates. For self-hosting cost comparisons, use the PaaS Tax Calculator.