
This is part of a series on the modern web stack, written from a WordPress developer’s seat for people who’ve built on the web for years and still hit stack terms they can’t define. The goal is literacy, enough that you can read any stack list and know what each piece does.
Each post has a 10-15 minute audio companion, generated with NotebookLM, for the gym or the commute.
Hosting is where the old mental models break down hardest for WordPress developers. Kinsta, WP Engine, Servebolt, SiteGround back in the day: you knew what you were getting. A Linux box, Nginx or Apache, PHP, MySQL, SSH access, a control panel, monthly billing tied to a plan tier. That model hasn’t changed since 2010.
Then someone tells you their Next.js app runs on Vercel, auth lives on Clerk, the database is on Neon, email goes through Resend, and uploads land in Cloudflare R2. Five services, one application. Where does it live? Who’s the host? What does the bill look like? When you say “the production environment,” what do you mean?
This post untangles the landscape: what changed, what each major platform is, and how to think about hosting when “where does the code run” has several answers per project.
Hosting Is Now Three Things
Hosting used to be one thing and is now three.
The runtime
The runtime is where your application code executes. In WordPress it was always the same machine that served files and ran the database. In the modern stack your code can run on a server (Node, Bun, Deno), at the edge (Cloudflare Workers, Vercel Edge), or as static HTML built ahead of time. The runtime decides which features your app can use and how it scales.
The data layer
The data layer is where your data lives: managed databases, auth providers, storage services. The posts on databases beyond shared MySQL and auth in 2026 covered these. It’s almost always separate from the runtime now.
The delivery layer
The delivery layer is how visitors reach your app: a CDN that caches static assets close to users, an edge network that routes requests to the nearest runtime, DNS that maps your domain to the right service. WordPress users met this layer through Cloudflare, bolted on. In the modern stack it’s often the platform itself.
Platforms package these three differently. Vercel bundles everything for Next.js apps. Cloudflare R2 handles storage and Neon handles data, each in a single layer. Fly.io and Railway offer all three, configured separately.
Pricing follows the same split. Traditional hosting bills for the machine: $20 a month for a shared box, $200 for a dedicated one. Modern platforms bill for usage: invocations, bandwidth, build minutes, database compute hours, storage GB-months. That’s great until it isn’t. It suits small apps and occasionally surprises you on ones that take off.
The WordPress Analogue
Vercel is to Next.js apps what Kinsta is to WordPress. Both are managed platforms that take one kind of project and run it well. Both bundle CDN, deployment automation, scaling and observability. Both have an opinionated workflow: you push to git, the platform builds and deploys. Both lock you in just enough that leaving takes real work.
The big difference is scope. Kinsta runs one piece of software (WordPress) on one runtime (PHP-FPM, Nginx and MySQL). Vercel runs anything that builds with a Node-compatible toolchain, on at least three runtimes (Node, Edge, static). That flexibility is why Vercel feels both magical and complicated, and why Next.js and Vercel read as a single product to most people.
The Hosting Platforms You’ll Weigh
These are the major platforms in the modern stack, in rough order of when you’d reach for each.
Vercel
The hosting company started by the creators of Next.js. The Next.js story is so polished here that “Next.js on Vercel” has become its own bundled noun. Image resizing, ISR, edge middleware and deploy previews per pull request are all native. It works with other frameworks too (Astro, SvelteKit), but Next.js gets the deepest integrations. The free tier is generous for hobby projects, and pricing escalates fast at scale.
Netlify
Netlify is the older Vercel equivalent. It’s strong on static sites, decent on serverless functions, less aggressive on Next.js and solid on other frameworks. The Jamstack pioneer is slightly behind Vercel on modern features in 2026 but still a credible default.
Cloudflare Pages and Workers
Cloudflare Pages and Workers are Cloudflare’s run-your-code platform, built on the Workers runtime. It’s very cheap at scale and fast at the edge, with different runtime constraints than Node: Workers run a subset of Node APIs, which trips up many libraries. It fits apps that already commit to the Cloudflare ecosystem (R2, D1, KV, Durable Objects).
Fly.io
Fly.io runs your app in containers on a global Anycast network. It’s closer to traditional VPS hosting than Vercel, with modern deploy and scaling. It suits apps that need long-running processes, WebSockets, or runtimes the serverless platforms don’t support.
Railway
A polished platform for running services (web apps, workers, cron jobs, databases) in containers. The developer experience is great, and it’s a good fit for monolithic apps and side projects. It focuses less on edge and static, more on “I have a Node app and I want it to run.”
Render
Render is similar to Railway: long-running services, managed databases and cron jobs behind a clean dashboard. Teams escaping AWS who don’t want Vercel-style serverless often land here.
AWS, Google Cloud and Azure
The hyperscalers (AWS, Google Cloud, Azure) give you maximum flexibility and maximum operational overhead. Most modern stacks avoid touching them directly until the team is large enough to justify the complexity. Vercel and Netlify both run on AWS under the hood, and you’re paying them to handle AWS for you.
Self-hosted platforms
Coolify, Dokku and CapRover on Hetzner, DigitalOcean or OVH give you the modern deploy workflow on your own infrastructure. They set up a PaaS-like experience on a VPS, which is worthwhile for cost-conscious projects or specific regulatory needs.
| Platform | Best for | Bundles | Pricing model |
|---|---|---|---|
| Vercel | Next.js apps, anything wanting deep DX | CDN, serverless, edge, image opt, previews | Free tier, then per-invocation / bandwidth |
| Netlify | Static + serverless, Jamstack defaults | CDN, functions, forms, identity | Free tier, then per-build / bandwidth |
| Cloudflare Pages | Edge-first, cost-conscious, full Cloudflare stack | CDN, Workers, R2, D1, KV | Generous free tier, very cheap at scale |
| Fly.io | Long-running processes, regional anycast | Container hosting, Postgres, scaling | Per-second compute, generous free tier |
| Railway | Easy “just run my app” deployments | Containers, databases, cron, queues | Per-second compute, generous free tier |
| Render | Production-grade managed services | Containers, databases, static sites | Tier-based, predictable |
| Self-hosted (Hetzner + Coolify) | Cost / data sovereignty | DIY, you run the platform | VPS rental ($5-50/mo) |
For a default 2026 stack: Vercel for Next.js apps, Fly.io or Railway for non-Next.js Node apps, Cloudflare Pages for static or Workers-friendly stacks, self-hosted for cost-conscious side projects.
What This Changes for WordPress People
Three practical implications.
“Where does this site live?” stops having a single answer. A modern client project might run on Vercel, with a database on Neon, uploads on Cloudflare R2, email through Resend and auth on Clerk. The architecture conversation needs more vocabulary, but the pieces compose well once you know them.
Pricing forecasts get harder. Kinsta is a predictable monthly bill. Vercel plus Neon, Clerk and Resend is several smaller bills that can spike under load. For client work, you scope projects with a small pricing-sensitivity model instead of picking a plan tier.
WordPress can stay where it lives while the rest of the stack modernizes. Keep Kinsta or WP Engine for the CMS, run a Next.js or Astro frontend on Vercel, and have the two share a Neon database for non-content state. Hybrid hosting is the sweet spot for many client projects, which is the setup the headless WordPress post walks through.
Cold Starts and Other Surprises
A few traps.
Cold starts
Serverless platforms spin up the runtime per request after idle periods. The first request after idle can take 500ms to several seconds, which matters for low-traffic apps where every request is a cold start. Platforms mitigate this (Vercel Fluid, Cloudflare warm starts) but haven’t eliminated it. The serverless and edge post covers why it happens.
Bandwidth pricing
Compute pricing is usually predictable. Bandwidth pricing is where a viral post or a runaway video embed bankrupts a side project. Read the bandwidth tier of any platform before you commit, especially if you serve audio, video or large images.
Region
A Vercel function in iad1 (Virginia) is fast for US users and slow for EU users. A database in eu-west-1 is slow for both unless the app also runs in Europe. Pair the runtime and the data layer in the same region for most projects. Multi-region is hard.
Lock-in
Vercel-specific features (ISR, edge middleware, image resizing) won’t work the same way on Cloudflare or Netlify. Cloudflare-specific features (Workers KV, Durable Objects) won’t work elsewhere. Build with portability in mind if you might ever move, and commit to platform-specific features when the productivity gain justifies the lock-in.
Free tiers
Several platforms have generous free tiers that enforce hard limits when you exceed them. Supabase pauses the database after a week of inactivity on the free tier, and Netlify charges $20 for the first build minute over quota. Free tiers suit prototypes. Budget the paid tier from day one for anything client-facing.
Choosing the Right Platform
To develop a sense of when to reach for which platform, a few resources are worth your time.
YouTube, for the gym or commute
- “Vercel vs Netlify vs Cloudflare in 2025” by various creators on the Theo channel and similar. Watch the comparisons critically, since opinions shift fast.
- “Self-hosting with Coolify” by Dreams of Code (about 20 minutes). Useful even if you stay on Vercel, because knowing the alternative sharpens your thinking.
Official docs worth bookmarking
- Vercel docs. The “Functions” and “Edge Network” pages explain what makes Vercel different from a traditional host.
- Cloudflare Workers docs. Read the “Compatibility” pages first for which Node APIs work.
- Fly.io docs. Worth a skim even if you don’t use Fly, since the documentation is opinionated and educational.
The next post goes deeper on what “serverless” and “edge” mean, since both terms get used loosely and the difference matters.

Leave a Reply