Five ways to put a Next.js or NestJS app on the internet, measured against their own documentation as of November 11, 2026. Three are managed platforms that sell compute by the millisecond and traffic by the gigabyte: Vercel, Netlify and Cloudflare Workers. Two, Coolify and Dokploy, are open-source control planes you install on servers you rent. They do not sell compute at all; they sell you the option of no longer paying someone else for it.
A managed platform's limits are a contract; a self-hosted panel's limits are whatever your server and your patience allow. Every figure below comes from the vendors' own pages, opened today. Where a number is not published, the tables say so.
Three billing philosophies behind similar price tags
Vercel Pro costs $20 per developer seat per month and includes $20 of usage credit. After that, everything is metered: $0.60 per million invocations, $0.128 per Active CPU hour and $0.0106 per GB-hour of provisioned memory in the cheapest US regions, rising to $0.184 and $0.0152 in Frankfurt. Hobby is free, capped at 100 GB of transfer, 1 million invocations, 4 Active CPU hours and 360 GB-hours of memory a month, and cannot buy more. The newest wrinkle is Flat Rate CDN: Pro includes 1 million CDN requests and 1 TB of transfer, and above that you buy a fixed tier at $20, $100 or $300 a month instead of paying per gigabyte.
Netlify now spends everything from one purse. Free gets 300 credits with a hard limit, Personal 1,000 and Pro 3,000, at $0, $9 and $20 a month. A production deploy costs 15 credits, a GB-hour of function compute 10, a GB of bandwidth 20, and 10,000 requests 2. Pro top-ups are 1,500 credits for $10. Run dry without auto-recharge (off by default) and every project is paused behind a "Site not available" page.
Cloudflare's Workers Paid has a $5 monthly minimum covering 10 million requests and 30 million CPU milliseconds, then $0.30 per million requests and $0.02 per million CPU-ms, with no charge for egress and none for static asset requests. The free plan allows 100,000 requests a day.
Coolify and Dokploy cost nothing to self-host. Their hosted control planes are Coolify Cloud at $5 a month for two servers plus $3 per extra server and Dokploy Cloud at $4.50 per server, with a Startup plan starting at $15 a month. The servers themselves are still yours to rent.
- Vercel · Entry paid plan: Pro · Base price (USD/month): 20 per developer seat · Included each month: $20 usage credit; 1M CDN requests and 1 TB transfer · What is metered: Active CPU-hours, memory GB-hours, invocations, origin transfer, build minutes
- Netlify · Entry paid plan: Personal / Pro · Base price (USD/month): 9 / 20 · Included each month: 1,000 / 3,000 credits · What is metered: Credits for deploys, compute GB-hours, bandwidth, requests
- Cloudflare Workers · Entry paid plan: Paid · Base price (USD/month): 5 (minimum) · Included each month: 10M requests, 30M CPU-ms · What is metered: Requests and CPU-ms; egress free
- Coolify · Entry paid plan: Cloud (self-hosted free) · Base price (USD/month): 5 for 2 servers · Included each month: Control plane only · What is metered: +$3 per server; servers billed by your host
- Dokploy · Entry paid plan: Cloud Hobby / Startup · Base price (USD/month): 4.50 per server / 15 for 3 · Included each month: Control plane only · What is metered: +$4.50 per server; servers billed by your host
Compute: what a millisecond costs and how long it may run
The managed three do not even agree on what a unit of compute is. Vercel bills Active CPU only while code executes, pausing during I/O, but bills provisioned memory for the instance's whole lifetime, and one instance can serve several requests at once. Netlify bills allocated memory multiplied by execution time, the classic Lambda GB-hour. Cloudflare bills CPU time alone; waiting on fetch, KV or a database is free.
Ceilings follow the same fault lines. Vercel Pro functions run 300 seconds by default, 800 at most, 1,800 in beta, with up to 4 GB and 2 vCPU; Hobby stops at 300 seconds and 2 GB. Netlify synchronous functions end at 60 seconds, not configurable, with 15 minutes for background functions and 1,024 to 4,096 MB of memory on credit-based Pro. Workers have no wall-clock limit on HTTP requests, a CPU budget of 30 seconds by default and 5 minutes at most on Paid, and 128 MB per isolate. Free Workers get 10 ms of CPU.
- Vercel (Pro) · Billing unit: CPU-hour + memory GB-hour + invocation · Max memory: 4 GB, 2 vCPU · Max wall-clock, HTTP (s): 800 (1,800 beta) · CPU-time cap: Not published · Body limit (MB): 4.5 request or response; streaming exempt · Concurrency: Auto-scales to 30,000
- Netlify (Pro) · Billing unit: Memory GB-hour · Max memory: 4,096 MB, 2 vCPU · Max wall-clock, HTTP (s): 60 sync; 900 background · CPU-time cap: Edge functions: 50 ms · Body limit (MB): 6 buffered; 20 streamed · Concurrency: Not published
- Cloudflare Workers (Paid) · Billing unit: CPU-ms + request · Max memory: 128 MB per isolate · Max wall-clock, HTTP (s): No limit · CPU-time cap: 30 s default, 300 s max · Body limit (MB): 100 request (Free/Pro zones); no response cap · Concurrency: No general requests-per-second limit
- Coolify / Dokploy · Billing unit: Your server · Max memory: Your server · Max wall-clock, HTTP (s): Your proxy config · CPU-time cap: Your server · Body limit (MB): Your proxy config · Concurrency: Your server
That 128 MB is per isolate and shared by every request it serves. A lean router in front of a database fits comfortably; a NestJS monolith with a fat dependency graph is a harder squeeze.
Deployments, builds and storage
Vercel caps every build at 45 minutes on every plan, with 64 GB of build disk, CLI source uploads of 100 MB on Hobby and 1 GB on Pro, and 15,000 source files. Functions may be 250 MB uncompressed, 500 MB for Python, or 5 GB under the large-functions beta. Pro builds are themselves metered, from $0.007 a minute on a Basic machine to $0.105 on Turbo.
Cloudflare is strict on size and generous on count. A Worker may be 64 MiB uncompressed on either plan, with no compressed limit and a one-second startup budget; static assets allow 20,000 files on Free and 100,000 on Paid, at 25 MiB each. Workers Builds include 3,000 minutes on Free and 6,000 on Paid, then $0.005 a minute, with a 20-minute timeout. Pages shares the 20-minute timeout and 25 MiB file cap, with 500 builds a month on Free.
Netlify is the hardest to pin down. Its docs publish edge function limits of 20 MB compressed, 50 ms of CPU and 512 MB of memory, and concurrent builds of 1 on Free and 3 on Pro, at $40 a month for each extra. The pages checked state no build timeout, function bundle size or deploy size, and the plans page contradicts itself on Personal concurrent builds: 3 at most in one table, no limit in another.
- Vercel (Pro) · Build timeout (min): 45 · Build time included: None; from $0.007/min · Function bundle: 250 MB (5 GB beta) · Static files per deploy: 15,000 source files via CLI; build output unlimited · Max static file: Not published (1 GB total CLI upload) · Concurrent builds: Up to 500
- Netlify (Pro) · Build timeout (min): Not published · Build time included: Not metered; 15 credits per production deploy · Function bundle: Not published (edge: 20 MB compressed) · Static files per deploy: Not published · Max static file: Not published · Concurrent builds: 3, +$40/month each
- Cloudflare Workers (Paid) · Build timeout (min): 20 · Build time included: 6,000 min, then $0.005/min · Function bundle: 64 MiB uncompressed · Static files per deploy: 100,000 · Max static file: 25 MiB · Concurrent builds: 6
- Coolify / Dokploy · Build timeout (min): Your config · Build time included: Your CPU · Function bundle: Your disk · Static files per deploy: Your disk · Max static file: Your disk · Concurrent builds: Your server
Bundled storage, briefly: Vercel Blob is 1 GB on Hobby and $0.023 per GB on Pro; Workers Paid includes 1 GB of KV and 5 GB of D1, with R2 free up to 10 GB-month.
Bandwidth is where the bills part ways
Egress decides most of these comparisons. Cloudflare charges nothing. Vercel Pro includes 1 TB, and the $20 tier lifts that to 50 TB alongside 10 million CDN requests; uncached function responses, however, also cross Fast Origin Transfer at $0.06 per GB, which Flat Rate CDN does not cover. The flat tiers also exclude bulk downloads and media-heavy delivery, and Vercel may move such projects onto its Flex CDN tier or limit service.
Netlify charges 20 credits per GB, roughly $0.13 at Pro top-up rates, and function responses count toward it. Pro's 3,000 included credits therefore buy 150 GB of traffic if spent on nothing else. A Hetzner CX33 includes 20 TB a month, with additional EU traffic listed at €1.00 per TB, excl. VAT.
Self-hosted reality: cheap servers, expensive attention
Coolify asks for 2 CPU cores, 2 GB of RAM and 10 GB of free disk on amd64 or arm64, and warns that running builds on the same box can make it unresponsive. Dokploy asks for 2 GB of RAM, 30 GB of disk and free ports 80, 443 and 3000, and names no CPU minimum. Neither publishes a measured idle footprint, and no methodology-disclosing third-party measurement turned up; the minimums are the only defensible numbers.
Licensing is where the two diverge. Coolify is Apache-2.0, currently at v4.6.0, released November 2, 2026. Dokploy, since January 21, 2026, is split: unmodified Apache 2.0 outside its proprietary/ directories, and a source-available license inside them that requires a paid license for production use. The project gives SSO, white-labelling and high availability as examples of what may become paid; existing open features stay open, the project says. GitHub tags v0.30.0 as the latest release.
On Hetzner, after the price adjustment of 15 June 2026, a CX33 (4 vCPU, 8 GB, 80 GB NVMe) lists at €8.99 a month including IPv4, excl. VAT. The adjustment moved it from €6.49 to €8.49 before IPv4. The Arm CAX21 is €10.99 and a CX23 for a separate build box €5.99.
- License · Coolify: Apache-2.0 · Dokploy: Apache 2.0 core; source-available
proprietary/directories - Latest release · Coolify: v4.6.0 (2 Nov 2026) · Dokploy: v0.30.0 (tagged Latest)
- Minimum CPU · Coolify: 2 cores · Dokploy: Not published
- Minimum RAM (GB) · Coolify: 2 · Dokploy: 2
- Minimum disk (GB) · Coolify: 10 free · Dokploy: 30
- Hosted control plane (USD/month) · Coolify: 5 for 2 servers, +3 per server · Dokploy: 4.50 per server; 15 for 3
- One Hetzner CX33 (EUR/month, excl. VAT) · Coolify: 8.99 · Dokploy: 8.99
- CX33 plus CX23 build server (EUR/month, excl. VAT) · Coolify: 14.98 · Dokploy: 14.98
What the euros do not buy: OS and Docker patching, backups you have actually restored, monitoring, a second region, DDoS absorption and the 3 a.m. page. Coolify Cloud takes over control-plane hosting, updates and instance backups, not your application servers.
Benchmarks: one honest data point, and it is a year old
The one public, methodology-disclosed benchmark spanning these platforms that we found is Theo Browne's independent cf-vs-vercel-bench from October 2025, and both vendors published interested readings of it. Vercel's post of October 9, 2025 reported Fluid compute on 2 vCPU and 4 GB averaging 0.534 seconds on the Next.js test against 1.895 seconds on Workers' 128 MB isolates, and 2.55 times faster across five workloads. Cloudflare's reply of October 14 put the original gap at as much as 3.5 times, traced it to its own isolate scheduling, a 2017 garbage-collector setting worth about 25%, OpenNext buffer copies and flaws in the benchmark, and reported parity after fixes in every case except Next.js.
Treat both as vendor readings of mismatched configurations, a year stale. Nothing credible and current covers Netlify, cold starts across all three, or Coolify and Dokploy idle usage.
Two workloads, priced from the rate cards
Workload A, a small Next.js SaaS: 8 million requests a month, 3 million dynamic; 500 GB egress; 15 ms CPU and 150 ms wall-clock per dynamic request; 40 KB dynamic responses; 60 production deploys of 4 build-minutes. Workload B: 40 million requests, 10 million dynamic at 10 ms CPU and 100 ms wall-clock, 4 TB egress, same deploys. Vercel uses iad1 rates and its 2 GB default; Netlify its 1,024 MB default. Memory assumes one request per instance, an upper bound for Vercel, whose Fluid instances share. Vercel's docs do not say whether the Pro plan's $20 monthly credit can pay the Flat Rate CDN tier fee; these bills assume it cannot. If it can, Workload A falls to $34.93 and Workload B is unchanged, because its usage already exceeds the credit.
- Vercel: Pro seat, includes $20 credit · Workload A: $20.00 · Workload B: $20.00
- Vercel: Flat Rate CDN tier (by CDN requests) · Workload A: $20.00 (10M tier) · Workload B: $100.00 (50M tier)
- Vercel: invocations ($0.60 per 1M) · Workload A: $1.80 · Workload B: $6.00
- Vercel: Active CPU ($0.128 per hour) · Workload A: $1.60 (12.5 h) · Workload B: $3.56 (27.78 h)
- Vercel: memory, 2 GB ($0.0106 per GB-h) · Workload A: $2.65 (250 GB-h) · Workload B: $5.89 (555.56 GB-h)
- Vercel: origin transfer ($0.06 per GB) · Workload A: $7.20 (120 GB) · Workload B: $24.00 (400 GB)
- Vercel: builds, Basic ($0.007 per min) · Workload A: $1.68 (240 min) · Workload B: $1.68 (240 min)
- Vercel: usage beyond the $20 credit · Workload A: $0.00 (usage $14.93) · Workload B: $21.12 (usage $41.12, unrounded; rounded lines sum to $41.13)
- Vercel Pro total (USD/month) · Workload A: 40.00 · Workload B: 141.12
- Netlify: requests (2 credits per 10k) · Workload A: 1,600 credits · Workload B: 8,000 credits
- Netlify: bandwidth (20 credits per GB) · Workload A: 10,000 credits · Workload B: 80,000 credits
- Netlify: compute, 1 GB (10 credits per GB-h) · Workload A: 1,250 credits (125 GB-h) · Workload B: 2,778 credits (277.78 GB-h)
- Netlify: production deploys (15 credits each) · Workload A: 900 credits · Workload B: 900 credits
- Netlify: credits beyond 3,000, in $10 packs of 1,500 · Workload A: 10,750 = 8 packs, $80 · Workload B: 88,678 = 60 packs, $600
- Netlify Pro total (USD/month) · Workload A: 100.00 · Workload B: 620.00
- Cloudflare: Paid minimum · Workload A: $5.00 · Workload B: $5.00
- Cloudflare: Worker requests beyond 10M ($0.30 per 1M) · Workload A: $0.00 (3M) · Workload B: $0.00 (10M)
- Cloudflare: CPU beyond 30M ms ($0.02 per 1M ms) · Workload A: $0.30 (15M ms) · Workload B: $1.40 (70M ms)
- Cloudflare Workers Paid total (USD/month) · Workload A: 5.30 · Workload B: 6.40
- Coolify or Dokploy, one Hetzner CX33 · Workload A: €8.99 excl. VAT, $0 panel · Workload B: €8.99 excl. VAT, $0 panel
One CX33 covers both workloads on paper: 4 TB sits well inside 20 TB, and Workload B averages 3.86 dynamic requests a second.
Three caveats. Vercel's docs do not say whether the usage credit absorbs a Flat Rate tier fee, so the tier is added on top. Netlify's larger Pro bundles of 5,000 to 20,000 credits were unpriced on the pages checked, and B's volume is an Enterprise conversation there. And the same request burns different CPU on a V8 isolate than on Node.
What we could not verify
Some of what an engineer would want to compare is not published, and some of what is published is ambiguous. Rather than fill those gaps with guesses, here they are in one place.
- Not published at all: Netlify's build timeout, function bundle size, maximum deploy size and function concurrency; a CPU-time cap for Vercel Functions; a minimum CPU for Dokploy. The tables say "not published" wherever these would sit.
- Ambiguous or contradictory on the official pages: Netlify's plans page gives two different figures for concurrent builds on the Personal plan. Hetzner's page prices each extra terabyte of traffic at "€1.00 per hour", which we read as per terabyte. Dokploy's release page dates v0.30.0 "14 Aug" with no year. Vercel's docs do not say whether the Pro plan's $20 monthly credit can pay the Flat Rate CDN tier fee; the worked bills assume it cannot, and if it can, Workload A drops from $40.00 to $34.93.
- Derived, not quoted: Netlify publishes prices in credits. Every Netlify dollar figure here, such as roughly $0.13 per GB, is our arithmetic from its credit price.
- Not measured by anyone credible: cold starts across the three managed platforms, Netlify's runtime performance, and how much CPU and memory Coolify and Dokploy consume when idle. The one public benchmark we found is a year old, covers only Vercel and Cloudflare, and each vendor reads it in its own favour.
- Availability on the day: Hetzner showed its cost-optimized server types as "currently unavailable" when we checked, so the €8.99 server may not be orderable when you read this.
Every value in this post, with its source link and the date we read it, is in the data sheet that accompanies it.
The 30,000-foot read
These five do different jobs, so the useful question is which worry you would rather stop carrying. Vercel sells the most integrated Next.js path, real memory and long durations; the costs gather in seats and origin transfer, and Flat Rate CDN now makes bandwidth predictable up to 50 TB. Netlify's credits are easy to read and severe on egress: comfortable below about 150 GB a month, expensive well above it. Cloudflare is the cheapest managed option by a wide margin at these volumes, with free egress, and asks in return that your code fit a 128 MB isolate that is not quite Node.
Coolify and Dokploy offer the cheapest compute and the most expensive attention. If you already run Hetzner with Terraform and Docker, one more box costs roughly what the invoice says; the risk is that everything, database to deploy pipeline, lives on one machine you answer for. Watch three things: Vercel's on-demand rates above the top flat tier, the prices of Netlify's larger credit bundles, and how much of Dokploy's roadmap lands in proprietary/. The rest is arithmetic, and arithmetic does not care about anyone's landing page.
Sources: Vercel pricing (Pro seat and credit, Hobby allowances, per-unit rates, build machine prices, Blob, origin transfer); Vercel Fluid compute pricing (Active CPU and memory billing model, regional rates); Vercel Flat Rate CDN (tiers, covered resources, eligibility); Vercel limits (build time, disk, uploads, files, concurrent builds); Vercel Functions limits (memory, duration, bundle size, body size, concurrency); Netlify pricing (plan prices); Netlify credit-based plans (credits, rates, recharge packs, concurrent builds); Netlify how credits work (GB-hour definition, pausing at zero credits); Netlify functions configuration (memory, execution limits, payloads); Netlify edge function limits (edge CPU, memory, code size); Cloudflare Workers limits (CPU, memory, size, static assets, body size); Cloudflare Workers pricing (Paid plan rates, free egress, KV, R2, D1); Workers Builds limits and pricing (build minutes, timeout, concurrency); Cloudflare Pages limits (builds, files, timeout); Coolify pricing (Cloud prices); Coolify installation (requirements); Coolify self-hosted vs Cloud (what Cloud manages); Coolify changelog (v4.6.0); coollabsio on GitHub (Apache-2.0 license); Dokploy installation (requirements, ports); Dokploy pricing (Cloud plans); Dokploy license update (dual license, date); Dokploy v0.30.0 release (latest tag); Hetzner cost-optimized cloud (server prices incl. IPv4, traffic); Hetzner price adjustment (15 June 2026 change, prices excl. IPv4); Vercel benchmark post (vendor reading of the October 2025 benchmark); Cloudflare benchmark post (vendor reply and fixes); OpenStatus latency comparison (reviewed and excluded: undated, no Vercel or Netlify). All figures retrieved 2026-11-11 and listed with exact URLs in hosting-comparison-data.csv. CAVEAT: Hetzner prices exclude VAT; its page showed a "currently unavailable" notice on the cost-optimized types at retrieval, and its overage sentence literally reads "€ 1.00 per hour" for each additional TB, reported here as per TB. Netlify's build timeout, function bundle size and deploy size limits were not published on the pages checked, and its plans page conflicts with itself on Personal concurrent builds. Dokploy's GitHub release page shows "14 Aug" without a year for v0.30.0. Both benchmark posts are vendor-written readings of an independent benchmark (repository linked from both, not re-run here). Worked bills are list-price arithmetic on stated assumptions, exclude tax, and do not convert EUR to USD; Vercel's docs do not say whether the $20 Pro credit covers the Flat Rate CDN tier fee, and the bills assume it does not. Netlify's dollar figures are derived from its credit prices, not printed on its pricing page. Vercel publishes no CPU-time cap and Dokploy no minimum CPU, and nobody has published credible measurements of Netlify cold starts or of Coolify and Dokploy idle usage. All figures are as published on November 11, 2026, and each of the 162 values in the accompanying data sheet was checked a second time against its source page that day; these pages change often.