For a side project, the short answer is: Cloudflare Pages if you want the cheapest ceiling and never think about bandwidth, Vercel if you're on Next.js and want the smoothest developer experience, Netlify if you want a mature all-in-one with forms and identity baked in. All three have a free tier that will host a hobby app fine. The differences that actually bite you show up later — when a post gets traffic, when your build gets slow, or when you outgrow static files and start running server code.
I've deployed personal projects on all three over the last couple of years. Below is how I'd choose today, with the real trade-offs rather than the marketing version.
What are you actually deploying?
Before comparing platforms, be honest about your app, because it changes the answer more than any feature chart:
- Pure static site (docs, a marketing page, a SPA that talks to an external API): all three are excellent and free. The decision barely matters.
- Static frontend + a few serverless functions (a contact form handler, an auth callback, a small API): now runtime, cold starts, and function limits matter.
- A full framework app with server rendering (Next.js App Router, SvelteKit, Remix): now framework-specific adapters and edge/runtime compatibility matter a lot.
The takeaway: pick based on your heaviest workload, not your current one — migrating hosts after you've wired up auth and functions is the annoying part.
How do the free tiers really compare?
This is where these platforms differ the most for hobby use. The headline distinction, as of mid-2026: Cloudflare Pages does not meter bandwidth on its free plan, while Vercel and Netlify both count usage (bandwidth, function invocations, build minutes) against free-tier limits and will ask you to upgrade — or throttle — when you cross them.
| Concern | Vercel (Hobby) | Netlify (Free) | Cloudflare Pages (Free) |
|---|---|---|---|
| Bandwidth | Metered, capped | Metered, capped | Unlimited |
| Build minutes | Limited | Limited | Limited (per-month build count) |
| Serverless/edge functions | Yes, metered | Yes, metered | Yes, via Workers, generous request free tier |
| Static requests | Metered | Metered | Unlimited |
| Custom domain + SSL | Free | Free | Free |
| Commercial use on free tier | Restricted | Allowed | Allowed |
Two things I want to flag honestly. First, Vercel's Hobby plan is explicitly non-commercial — if your side project starts earning money, their terms expect you on a paid plan. Netlify and Cloudflare are more permissive about small commercial use on free tiers. Second, "unlimited bandwidth" on Cloudflare applies to static asset delivery; the compute side (Workers/Pages Functions) still has request and CPU-time limits. It's generous, not infinite.
Takeaway: if the thing you fear is a viral post turning into a bill, Cloudflare's model removes that fear more completely than the other two.
Which has the best developer experience?
Vercel wins this, and it isn't especially close — if you're building with Next.js. Vercel makes Next.js, so new framework features land on Vercel first and "just work": image optimization, ISR, the App Router, streaming. git push to a preview URL is the smoothest of the three. The cost of that smoothness is a soft gravity toward Next-specific features that are most turnkey on Vercel and take more effort to reproduce elsewhere.
Netlify's DX is the most mature and framework-agnostic. It pioneered the deploy-preview-on-every-PR workflow, and its dashboard covers builds, functions, forms, and redirects in one place. If you're on Astro, Hugo, Eleventy, or a non-Next framework, Netlify often feels more neutral and less like you're renting space in someone else's framework.
Cloudflare Pages has improved a lot but is still the roughest of the three for full-framework apps. The friction is that Pages Functions run on the Workers runtime, which is not Node.js. Compatibility has gotten much better with nodejs_compat, and many frameworks now ship Cloudflare adapters, but you're more likely to hit a library that assumes a Node API and doesn't work unmodified. The docs are also split across "Pages" and "Workers" in a way that can send you in circles.
Takeaway: Vercel for the frictionless Next.js path, Netlify for framework-neutral polish, Cloudflare when you're willing to trade some smoothness for the pricing model.
How do they handle server-side code and edge functions?
All three run your backend logic without you managing servers, but the runtimes differ, and that's the detail that trips people up.
- Vercel offers both a Node.js serverless runtime and an Edge runtime (a lighter, V8-based environment that runs closer to users but supports a narrower set of APIs). You choose per-function. Cold starts on the Node runtime exist but are usually tolerable for hobby traffic.
- Netlify Functions are built on AWS Lambda (Node.js), with Netlify Edge Functions running on Deno at the edge. Two runtimes with two capability sets, so read which one your code targets.
- Cloudflare Pages Functions run entirely on Workers — one consistent edge runtime, globally distributed, with genuinely fast cold starts. The catch is the runtime constraints mentioned above: it's V8/Workers, not Node, so some npm packages need a compat flag or won't run.
Here's the same trivial JSON endpoint on each, to make the shape concrete.
Vercel — api/hello.js:
export default function handler(req, res) {
res.status(200).json({ ok: true, host: "vercel" });
}
Netlify — netlify/functions/hello.js:
export async function handler(event, context) {
return {
statusCode: 200,
body: JSON.stringify({ ok: true, host: "netlify" }),
};
}
Cloudflare Pages — functions/hello.js:
export function onRequest(context) {
return new Response(JSON.stringify({ ok: true, host: "cloudflare" }), {
headers: { "content-type": "application/json" },
});
}
Notice Cloudflare uses the standard Request/Response Web APIs — nice if you like web standards, a small mental switch if you're used to Node's req/res. Takeaway: if your functions are simple and standards-based, Cloudflare's single fast runtime is great; if you depend on Node-specific libraries, Vercel or Netlify's Lambda-based runtime is the safer bet.
When is it worth upgrading to a paid plan?
For a genuine side project, often never — but the upgrade triggers differ, and knowing them helps you avoid picking a host you'll have to leave.
You'll typically consider paying when:
- Traffic outgrows the free bandwidth (Vercel/Netlify) — this is the most common trigger, and the one Cloudflare's model largely sidesteps.
- Builds get slow or frequent and you exhaust free build minutes — monorepos and large sites hit this first.
- You need team seats, password-protected previews, or longer function limits.
- Your project starts making money — on Vercel specifically, that pushes you off Hobby by policy, not just by usage.
I won't quote exact dollar figures because all three revise pricing and all three have usage-based components that make "the price" depend on your traffic. Check the current pricing pages before you commit; the pricing model (metered vs. flat, what counts as billable) matters more than any single number. Takeaway: choose the host whose paid model you'd also be comfortable with, since the free tier is where you start but not necessarily where you stay.
Bottom line
If your side project is static or standards-based and you never want to think about a bandwidth bill, Cloudflare Pages is the most worry-free home — accept a slightly rougher DX and the Workers-runtime caveat in exchange. If you're building on Next.js and want everything to just work with the least friction, Vercel is worth the metered pricing, as long as you keep an eye on usage and know Hobby is non-commercial. If you want a framework-neutral, mature all-in-one with forms, identity, and a clean dashboard, Netlify is the balanced pick. For most hobby apps, honestly, start on the free tier of whichever matches your framework, and only migrate if a real constraint — traffic, build time, or a runtime limit — actually forces the issue.
Top comments (0)