Get AI summaries of any video or article — Sign up free
Where Should You Deploy In 2026? thumbnail

Where Should You Deploy In 2026?

Theo - t3․gg·
6 min read

Based on Theo - t3․gg's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Start with serverless for most apps; move to VPS-style hosting only when the workload truly breaks serverless assumptions.

Briefing

Choosing where to deploy in 2026 comes down to matching workload constraints—runtime compatibility, concurrency, bandwidth, and operational reliability—to a platform’s underlying execution model. A strong default emerges for most teams: start with serverless for speed and simplicity, then move to traditional VPS-style hosting only when the workload truly demands it. The most practical takeaway is that “cheapest” and “best” depend less on marketing and more on where costs and failures show up: cold starts, concurrency limits, egress/bandwidth bills, database reliability, and the friction of CI/CD and infrastructure setup.

On the serverless side, the guidance is to treat AWS Lambda as possible but often painful. Lambda’s setup is non-trivial, concurrency is still described as not viable for many real-world needs, and common server patterns—like fast startup assumptions, HTTP streaming, and database connection behavior—can turn into performance or reliability traps. Even when code can be packaged into a Docker image, startup time can still be dominated by database connectivity rather than compute itself.

Cloudflare is framed as a performance-and-cost outlier because it runs JavaScript at the edge using its own execution stack (workerd and a custom V8). That design yields near-zero cold starts and a CPU-time-based pricing model that can be cheaper when requests are idle or waiting. But the tradeoff is compatibility: Cloudflare Workers don’t provide a full Node.js environment. File I/O, many database connectivity patterns, and native-code-dependent packages (examples include sharp and ffmpeg) can break or require shims that still leave gaps. The dashboard and documentation experience also draw heavy criticism, including claims of outdated or incorrect docs and recurring outages.

Versel is positioned as the most consistent serverless choice for typical web workloads, especially Next.js. It offers strong GitHub integration, a sensible billing model, and “fluid compute” pricing that aims to mirror CPU-time economics. The main cost risk isn’t compute—it’s bandwidth. Viral “sky-high” bills are attributed largely to large static assets (videos, big audio, large files) being served through Versel’s CDN. The advice is to keep public assets small (roughly under 400 KB) and use alternative storage approaches when larger files are needed.

Render and Railway round out the “recommended” set with different strengths. Render is described as reliable and used by major companies, with a decent free tier but pricing that can shift into monthly subscriptions and add-ons like cron setup; egress is also flagged as potentially expensive. Railway is praised for modern developer experience: excellent CLI, docs, observability, preview environments, and a dashboard that makes service relationships clear. Pricing is called relatively transparent, but egress and object storage details matter—free egress is treated as a “ticking timer,” and DNS/SSL workflows can sometimes be confusing.

For traditional VPS hosting, the transcript is skeptical of providers like Hetzner and OVH due to account policy risk, limited integration support, and location/latency concerns. DigitalOcean is respected for documentation quality and long-standing developer familiarity, but it’s not portrayed as cheap, and there are worries it feels directionless. Fly.io is praised for Elixir-native tooling and unusual primitives (like Flame for targeted GPU-style workloads), yet database reliability and outage history reduce confidence.

The final ranking emphasizes a practical decision tree: start with Railway, Versel, and Render; consider Cloudflare or Netlify only when their specific execution model or queuing/concurrency features fit; treat AWS and other “default” clouds as a fallback when required by employers; and regard the rest as situational. The overarching message: pick based on workload fit and cost drivers—especially bandwidth and egress—rather than brand loyalty or generic advice.

Cornell Notes

Deployment choices in 2026 should be driven by workload fit: runtime compatibility, concurrency behavior, bandwidth/egress costs, and operational reliability. For most apps, serverless is the default path—start there, and only move to VPS-style hosting when the workload truly needs it. AWS Lambda is often described as hard to recommend due to setup complexity and concurrency limitations, plus issues with startup-sensitive workloads and streaming patterns. Versel is presented as the most consistent serverless option for typical web apps (including Next.js), with the biggest cost risk coming from bandwidth-heavy static assets. Railway and Render are recommended alternatives, with Railway standing out for developer experience and observability, and Render for reliability—though both still require attention to pricing details like egress and add-on fees.

Why does Cloudflare’s execution model create both major advantages and major headaches?

Cloudflare runs JavaScript at the edge using its own runtime stack (workerd and a custom V8), which avoids traditional server spin-up and leads to near-zero cold starts. Pricing is also CPU-time-based, so idle/waiting requests can be cheaper because compute can be shared across concurrent workloads. The catch is compatibility: it’s not a full Node.js environment. File reads/writes, many database connection methods, and native-code packages (examples cited include sharp and ffmpeg for image/PDF/media workflows) can fail or require shims that still leave gaps. Native or non-JavaScript dependencies are a recurring reason people abandon Cloudflare for other platforms.

What cost driver is repeatedly blamed for “exploding” Versel bills?

Bandwidth. Versel’s CDN is optimized to make web assets load fast, but large static files placed in the public folder—like 50 MB videos, 10 MB images, or multi-megabyte audio—can trigger large charges. The transcript warns that this is like using a race car to pick up groceries: it’s the wrong fit and can increase both cost and maintenance. The suggested mitigation is to keep public assets small (roughly under 400 KB) and use alternative storage approaches (including Versel’s blob built on R2, with a mention of upload services as a cheaper workaround).

How does the guidance treat AWS Lambda’s concurrency and setup?

Lambda is described as not trivial to set up, with multiple tooling layers (SST, Pulumi, Terraform) still leaving a rough experience. Concurrency is portrayed as a key limitation: the transcript says concurrency isn’t viable for most people yet, with only emerging “concurrent Lambda” concepts that aren’t widely used. Additional friction includes awkward patterns around startup time (especially when database connection latency dominates), and problems with streaming behavior in server-style frameworks like Next.js.

What makes Railway stand out compared with other platforms, and what pricing detail needs scrutiny?

Railway is praised for modern developer experience: strong CLI, excellent docs, great GitHub integration, observability, and a dashboard that clearly shows how services link together. It also supports preview environments and one-click rollbacks, which can prevent costly mistakes. The pricing warning is about egress: while egress from object storage is described as free, object storage is private-only and free egress is treated as unlikely to remain free indefinitely. The transcript also notes egress charges for services (e.g., 5 cents per gig) and storage pricing (e.g., 1.5 cents per gig per month), so teams should model real usage rather than assume “free.”

Why is Fly.io both compelling and risky in this framework?

Fly.io is compelling for Elixir-native support and strong server deployment DX, including preview environments, sleeping servers, and a dashboard that provides clarity. It also offers unique primitives like Flame, which can spin up specialized compute (e.g., GPU-backed ffmpeg thumbnail generation) only when needed. The risk comes from database reliability: the transcript says databases have failed multiple times, outages have occurred, and reliability isn’t at the level teams need. It also notes that Fly historically didn’t manage databases (running Postgres in an image), though managed databases are said to have been added later.

What is the decision rule for when to start with serverless versus move to VPS-style servers?

The rule is to start with serverless if the app fits, because the transcript claims 98%+ of applications can run fine in serverless. If serverless limitations appear—often around runtime compatibility, concurrency, streaming, or operational needs—then moving to VPS-style hosting becomes straightforward. VPS hosting is reserved for cases where serverless compromises are unacceptable, not as a default preference.

Review Questions

  1. Which platform’s pricing model is described as CPU-time-based, and what runtime constraint drives the biggest compatibility tradeoff?
  2. What specific Versel cost risk is emphasized, and what practical asset-size guidance is given to avoid it?
  3. In this framework, what are the main reasons AWS Lambda is treated as difficult to recommend for most teams?

Key Points

  1. 1

    Start with serverless for most apps; move to VPS-style hosting only when the workload truly breaks serverless assumptions.

  2. 2

    Cloudflare can be extremely fast and cheap for CPU-idle workloads, but it’s not a full Node.js environment, making native-code and file/DB patterns risky.

  3. 3

    Versel’s biggest cost trap is bandwidth from large static assets served through its CDN; keep public assets small and use storage alternatives for bigger files.

  4. 4

    Railway’s developer experience—CLI, docs, observability, and service-linking dashboard—makes it a top pick, but egress/free tiers require careful modeling.

  5. 5

    Render is positioned as reliable and widely used, but subscription-based pricing and egress costs can surprise teams.

  6. 6

    AWS Lambda is often a poor default due to setup complexity and concurrency limitations, plus performance issues when startup time is dominated by database connections.

  7. 7

    Traditional VPS providers like Hetzner/OVH are treated as situational at best due to account/policy risk, limited integrations, and latency/location concerns.

Highlights

Cloudflare’s edge execution (workerd + custom V8) enables near-zero cold starts and CPU-time pricing, but the lack of a true Node.js environment breaks many real server workloads.
Versel bills can spike mainly due to bandwidth when large media/assets are placed in public folders; the transcript recommends keeping those assets under ~400 KB.
Railway is praised for modern DX and observability, with one-click rollbacks and clear service relationships—yet free egress is framed as temporary and should not be assumed.
Fly.io’s Flame primitive is highlighted as a unique way to run specialized workloads (like ffmpeg) only when needed, but database reliability is the recurring weak point.
AWS Lambda is described as hard to recommend for most teams because concurrency is still not viable and setup remains cumbersome.

Topics

Mentioned

  • DX
  • CI
  • CDN
  • EKS
  • VPS
  • SLAs
  • PRs
  • VM
  • CPU
  • NVME
  • SSH
  • GNU
  • Postgress
  • OSS