Where should I host my TanStack Start app? A 2026 field guide

So you vibe-coded a TanStack Start app — maybe in Lovable, maybe in Cursor, maybe by hand — and now you're staring at the deploy step wondering which logo to click. This post is the answer we wish we'd had: every realistic place to run TanStack Start in 2026, with the actual prices, actual runtime limits, and the actual reasons each one will or won't bite you.

We run TanStack workloads in production at BitFiction and ship the Staticbot DevOps agent that wires these stacks up for other teams, so the recommendations below are what we'd tell a friend, not what a vendor's docs page wants you to hear. Every number is sourced — links throughout, summary table at the end.

30-second answer

If you don't want to read 4,000 words:

• Static marketing site or docs with a thin SPA shell: prerender to HTML and host on Cloudflare Pages, S3 + CloudFront, Netlify, or Bunny CDN. ~$0/month at hobbyist traffic. This is what bitfiction.com does — see the previous post.
• Real app, edge-friendly code, want it cheap and global: Cloudflare Workers. $5/mo floor, free tier covers 100k requests/day, 5-minute CPU ceiling per request now (Cloudflare changelog, Mar 2025). Caveat: workerd isn't full Node.
• Real app, Node-only npm packages, AI/LLM workloads, want zero compatibility headaches: Vercel Functions on Fluid compute. Real Node 22, configurable up to 4 GB RAM per function, Active-CPU pricing means you don't pay while waiting on the model (Vercel KB).
• You want a long-running container, not a function, and you want to pay container prices: Bunny Magic Containers ($0.02/CPU-hr, $0.005/GB-RAM-hr, docs) or Fly.io / Railway / Render.
• You're already deep in AWS and your CTO will not approve anything else: AWS Lambda via the Nitro AWS preset, or a Fargate task behind an ALB.

The rest of this post is why.

How TanStack Start actually deploys

TanStack Start is a Vite-based, full-stack React framework: file-based routing, server functions, streaming SSR, optional prerendering. The piece that matters for hosting is how the server bundle gets produced. There are three buttons you can press:

• SPA / prerender mode. No SSR runtime in production. Vite emits HTML for every crawlable route plus a JS bundle. Anything that serves static files works — see the TanStack hosting guide.
• Cloudflare Vite plugin. @cloudflare/vite-plugin + wrangler builds a Worker that runs in workerd (V8 isolates). This is Cloudflare's officially supported path (Cloudflare docs).
• Nitro Vite plugin. Nitro is the universal server toolkit behind Nuxt, SolidStart, and TanStack Start's non-Cloudflare backends. Nitro has presets that emit a different output shape per target: vercel, netlify, aws-lambda, cloudflare-pages, deno-deploy, bun, node-server, and more. One NITRO_PRESET=... env var switches targets.

That last point is the secret to TanStack Start hosting in 2026: the framework code is identical on every platform. What changes is the runtime your server functions execute in, the cold-start behaviour, and the bill.

// vite.config.ts — minimal Cloudflare build
import { defineConfig } from "vite";
import { tanstackStart } from "@tanstack/react-start/plugin/vite";
import { cloudflare } from "@cloudflare/vite-plugin";

export default defineConfig({
  plugins: [cloudflare({ viteEnvironment: { name: "ssr" } }), tanstackStart()],
});

// vite.config.ts — minimal Nitro build (Vercel / Netlify / AWS / Node / Bun / Deno)
import { defineConfig } from "vite";
import { tanstackStart } from "@tanstack/react-start/plugin/vite";
import { nitro } from "nitro/vite";

export default defineConfig({
  plugins: [tanstackStart(), nitro()], // NITRO_PRESET=vercel|netlify|aws-lambda|...
});

The runtime axis: V8 isolates vs Node vs containers

Every host below falls into one of three buckets. Pick the bucket first, vendor second.

The Vercel-vs-Cloudflare table in Vercel's own KB article is unusually honest about the tradeoff: "Vercel Functions let you configure up to 4 GB of memory per function… Cloudflare Workers run with a fixed 128 MB limit per isolate." The 128 MB number is a hard physical ceiling on Workers — design around it, or don't pick it.

Option 1: Cloudflare Workers

The Cloudflare path is the most aggressively marketed and, for the right workload, the best deal in serverless.

Runtime. workerd, the same V8-isolate runtime that powers Cloudflare's own products. Each request runs in an isolate, not a process; isolates are reused across many requests, so cold start is effectively zero. nodejs_compat covers most Node built-ins but breaks on packages that need child_process, native bindings, or arbitrary filesystem access. (Cloudflare docs)

Pricing (Standard, [official source](https://developers.cloudflare.com/workers/platform/pricing/)):

There is no charge for duration, egress, or bandwidth. You pay for CPU time, not wall-clock. Cloudflare's own worked example: a Worker doing 15M req/mo at 7 ms CPU each costs $8/mo total ($5 + $1.50 requests + $1.50 CPU). 100M req/mo at the same shape is $45.40/mo. (Pricing examples)

Limits (source):

• 128 MB memory per isolate
• 5 min CPU per request (raised from 30 s in March 2025, changelog)
• 15 min CPU for Cron Triggers and Queue consumers
• 1,000 subrequests per invocation on Paid

Strengths: unbeatable price at scale, real global edge (300+ cities), first-party KV/R2/D1/Durable Objects/Queues, no egress fees. The Cloudflare Vite plugin runs the same `workerd` binary locally as in production, so "works on my machine" usually means "works in prod."

Gotchas for TanStack Start specifically:

• Any npm dep that imports sharp, puppeteer, canvas, or @aws-sdk/client-*-node (the ones that pull native shims) will fail. Replace before deploy, not after.
• process.env doesn't exist at request time — config comes through env bindings from cloudflare:workers.
• Server functions that try to write to /tmp for caching won't.

If you can live inside those rails, this is the platform we'd pick by default. It's what we recommend through Staticbot for "everything that isn't a static site."

Option 2: Vercel Functions (Fluid compute)

If Cloudflare is "edge, fast, cheap, weird runtime", Vercel is "Node, easy, expensive, no surprises."

Runtime. Vercel Functions on Fluid compute is real Node.js running on AWS Lambda underneath, with Vercel's Fluid layer enabling in-instance concurrency (one Node process serves many requests at once) and Active-CPU billing (you don't pay CPU while await-ing). Memory is configurable up to 4 GB per function (source).

Pricing (official):

Vercel's own example, verbatim: a function with 4 GB memory in São Paulo serving one request that uses 4 s of CPU and lives 10 s end-to-end costs $0.0004489 per invocation. (Source)

The Fluid pitch in one sentence: if your TanStack server functions spend most of their time await-ing an LLM, a database, or another HTTP API, you only pay CPU for the ~50 ms of glue code around the wait — same workload on classic Lambda billed you for the full wall-clock duration. Vercel published this as the June 2025 Active-CPU launch post, and it's the reason AI-heavy apps are migrating to Vercel.

Strengths: zero-config TanStack deploy (Vercel auto-detects Nitro), full Node compatibility, generous Hobby tier, built-in observability and WAF, the smoothest "git push and it works" flow in the industry.

Gotchas:

• Functions are regional, not edge. Hobby pins one region; Pro allows three; Enterprise unlimited. Latency to users on the other continent will be 100–200 ms worse than Cloudflare.
• Bandwidth and image-optimisation overages on Pro escalate fast above $20/mo. Read the pricing page end-to-end before you ship — many "Vercel is expensive" horror stories are bandwidth bills, not function bills.
• 800 s max wall-clock per request on Pro. Long jobs need Vercel Workflows or an external queue.

Option 3: Bunny.net — Magic Containers and Edge Scripting

Bunny.net is the dark-horse pick that very few TanStack tutorials mention and that almost always wins on $/req if you're price-shopping. They sell two relevant products:

Edge Scripting (the Cloudflare Workers competitor)

V8-isolate runtime, deployed to Bunny's CDN edge. Aimed at scripts up to a few hundred MB, intended for SSR shells, A/B routing, auth gateways. Pricing (official):

Bunny's worked example: 10M req/mo at 10 ms CPU each = $4.00/mo total ($2 CPU + $2 requests). 100M req/mo at 7 ms = $34.00/mo. Same shape on Cloudflare Workers is $5 + $27 + $13.40 = $45.40/mo (CF source) — Bunny wins by ~25% at the high end and the gap widens with traffic, since there's no $5 floor.

Note Bunny bills requests at 5× Cloudflare's per-million rate ($0.20 vs $0.30/M) but charges CPU at the same $0.02/M-ms — wait, do the math: $0.02/1000s = $0.02 per 1,000,000 ms, which is identical to Cloudflare's $0.02/1M CPU-ms. So Bunny is cheaper on requests (no $0.30/M floor, just $0.20/M flat) and identical on CPU.

Magic Containers (the Fly.io / Railway competitor)

Launched in 2024, generally available now. You hand them an OCI container, they run it globally with anycast routing. This is the right place to put a Node-based TanStack Start app that wants to be always-on. Pricing (official):

For context: an always-on container with 1 vCPU and 512 MB RAM runs ~$15/mo of CPU + ~$1.50/mo of RAM + $2 IP = ~$18.50/mo. The same workload on Fly.io's shared-CPU-1x with 512 MB is roughly $5–$7/mo, on Railway around $5/mo of compute credit, on AWS Fargate around $25–$30/mo. Bunny's pitch is bandwidth: $0.01/GB egress versus AWS at $0.08–$0.09/GB is the long-game saving for media-heavy apps.

Strengths: real container, real bandwidth pricing, anycast routing across Bunny's CDN POPs, generous free trial. The cheapest place to run a full Node TanStack Start app globally.

Gotchas: the platform is young — fewer integrations, no managed Postgres of their own, observability is basic, the dashboard is "improving." Their FAQ admits "no detailed cost breakdown is provided" yet. We use them for non-critical workloads and recommend kicking the tyres before betting a SaaS on it.

Option 4: AWS Lambda (via Nitro `aws-lambda` preset)

The grown-up choice when your employer has a signed AWS contract and a security team that says "no" to everything else.

Runtime. Node 22 on Lambda, behind an API Gateway, CloudFront, or Function URL. TanStack Start ships via the Nitro aws-lambda preset.

Pricing (official):

Worked example: 10M req/mo, 200 ms avg, 512 MB memory.

• Requests: (10M − 1M free) × $0.20/M = $1.80
• Compute: 10M × 0.2 s × 0.5 GB = 1,000,000 GB-s; minus 400k free = 600,000 GB-s × $0.0000166667 = $10.00
• Total: ~$11.80/mo, not counting API Gateway ($3.50/M req → +$31.50) or CloudFront.

That API Gateway line is the killer. Use Lambda Function URLs ($0, but no WAF/usage plans) or front with CloudFront ($0.085/GB out, free tier 1 TB/mo for first 12 months) and the bill stays sane.

Cold starts. For a TanStack Start SSR bundle (typically 5–15 MB), cold start in Node 22 is 200–800 ms warm-region, up to 2 s in a cold region. As of August 2025, AWS bills the INIT phase as well (AWS in Plain English) — if your bundle has heavy top-level imports, you now pay for the cold start too. AWS's own data says <1% of invocations experience a cold start (AWS Compute Blog), but a 2 s cold start on the request that loads your homepage is the one that matters.

Strengths: infinitely scalable, full Node, every AWS service one IAM role away, you can run it on your existing AWS account, free tier never expires.

Gotchas: the operational tax. You will set up CloudWatch log groups, build a CI pipeline, configure CloudFront cache behaviours, write CDK or Terraform. Lambda is the cheapest line item on the bill and the most expensive thing to operate. If you don't already speak fluent AWS, pick Vercel or Cloudflare and revisit in two years.

Option 5: Netlify

Netlify supports TanStack Start via Nitro and presents very similarly to Vercel. (Setup guide)

Pricing moved to a credit-based model in late 2025. Functions are billed in GB-hours of compute, default 1 GB memory. (Source) Free tier includes 300 credits/month; Pro is $25/mo with 1,000 credits.

Practically: if you're already on Netlify for static hosting, the migration to TanStack Start is one nitro preset and a redeploy. If you're greenfielding, Vercel's TanStack story is more polished and Cloudflare's is cheaper — Netlify is the "I'm already here" answer.

Option 6: Deno Deploy

Deno Deploy runs the framework via the Nitro deno-deploy preset. V8 isolates, global edge, similar shape to Cloudflare. Recently went GA in Feb 2026. Pricing tiers are at deno.com/deploy/pricing — Free tier is generous, Pro starts at $20/mo.

Strengths: native TypeScript, web-standard APIs, very clean DX. Gotcha: smaller ecosystem and fewer first-party data primitives than Cloudflare. Pick it if you're already a Deno shop, otherwise Cloudflare Workers does the same thing with more services attached.

Option 7: Containers and PaaS — Fly.io, Railway, Render

All three run a Docker container, all three give you a real always-on Node process, all three are well-loved by indie devs. (2026 comparison)

For TanStack Start specifically: these are the right answer if your app holds in-memory state, uses websockets, or has a long-running cron that doesn't fit the 15-minute Cloudflare Cron / 800 s Vercel function limit. You give up scale-to-zero and pay for an idle dyno, but you also stop fighting the runtime.

Option 8: Static-only (no SSR runtime at all)

If your app is content-driven — marketing site, docs, blog, portfolio — set spa: { enabled: true } and prerender: { enabled: true, crawlLinks: true } in vite.config and ship to any static host. This site does exactly that; see the previous post for the full setup.

Free or near-free options:

• Cloudflare Pages — unlimited bandwidth, free SSL, free.
• S3 + CloudFront — pennies per month at low traffic, ~$0.085/GB egress, requires a bit of Terraform (or Staticbot doing it for you).
• Netlify / Vercel — both have generous static tiers, but Vercel has bandwidth limits on Hobby (100 GB/mo) and image-optimisation limits that can bite if you go viral.
• Bunny CDN — $0.005–$0.06/GB depending on region, no minimums.

For a marketing site that gets 100k pageviews a month, all of these round to $0–$2. Pick on which dashboard you find least irritating.

The side-by-side, with money

Here's the comparison we wish vendor pages would publish. Assumptions: a TanStack Start app, 10 million requests/month, 7 ms CPU per request, ~100 ms wall-clock per request (mostly I/O), 512 MB peak memory. These are realistic SSR-heavy numbers.

Numbers are illustrative — your CPU profile is the swing factor. The point is the shape of the bill: edge-isolate platforms (Cloudflare, Bunny Edge) are flat and tiny; Node serverless (Vercel, Lambda, Netlify) climbs with active CPU; containers (Bunny MC, Fly, Railway, Render) are predictable and idle-pay.

$/month for ~10M req TanStack Start SSR app (lower = better)

Bunny Edge Scripting    ▓░░░░░░░░░░░░░░░░░░░░  $4
Cloudflare Workers      ▓░░░░░░░░░░░░░░░░░░░░  $5
Render Starter          ▓▓░░░░░░░░░░░░░░░░░░░  $7
AWS Lambda + FuncURL    ▓▓▓░░░░░░░░░░░░░░░░░░  $10
Fly.io shared-1x        ▓▓▓░░░░░░░░░░░░░░░░░░  $5–10
Railway Developer       ▓▓▓▓░░░░░░░░░░░░░░░░░  $10–15
Bunny Magic Containers  ▓▓▓▓▓░░░░░░░░░░░░░░░░  $18
Vercel Pro (Fluid)      ▓▓▓▓▓▓░░░░░░░░░░░░░░░  $22
Netlify Pro             ▓▓▓▓▓▓░░░░░░░░░░░░░░░  $25
AWS Lambda + APIGW      ▓▓▓▓▓▓▓▓▓▓▓▓░░░░░░░░░  $45

The decision matrix

Pick the row that fits, then the column that matches your team.

What we actually use

For full transparency, here's what we ship in production:

• **bitfiction.com**: static SPA, S3 + CloudFront, deployed by Staticbot. $1–2/mo end-to-end. See the build post.
• **staticbot.dev** control plane: TanStack Start on Cloudflare Workers with D1 and Durable Objects. Sub-$10/mo until paying customers tip it over.
• Internal long-running agent loops: containers on Fly.io because we need persistent websockets and 30-minute jobs.

The pattern: start static, move to Workers or Vercel for the first server functions, move to a container only when the workload demands it. Don't pre-optimize for traffic you don't have.

Closing notes for vibe coders

Three things we'd tell anyone shipping their first TanStack Start app:

• Don't pick the platform from the framework docs page. Pick it from your actual workload shape — Node compatibility, request rate, CPU per request, memory ceiling. The framework runs everywhere; you only pay the bill on one.
• Test the cold start. Cold-start a deploy in your worst region from your slowest network and watch the waterfall. A 2 s SSR cold start kills LCP scores and conversions in ways your $5/mo invoice doesn't show.
• Own the artifact. Whichever you pick, the source lives in GitHub, the build outputs plain JS, and the next vendor migration is a Nitro preset away. That's the actual durability story — not the logo on the dashboard.

If you want us to help wire this up — Staticbot does the S3/CloudFront/Workers/Lambda Terraform end of the story so you don't have to — say hi.

Sources

• TanStack Start hosting docs and deployment skill
• Vercel KB: TanStack Start on Vercel vs Cloudflare (June 2026)
• Cloudflare: Workers pricing, Workers limits, 5-min CPU changelog, TanStack guide
• Vercel: Fluid compute pricing, Active CPU launch (June 2025)
• Bunny.net: Magic Containers pricing, Edge Scripting pricing, Magic Containers launch post
• AWS: Lambda pricing, INIT billing change (August 2025), cold-start analysis
• Netlify: TanStack Start setup, functions pricing
• Deno: Deploy GA announcement (Feb 2026), pricing
• Container PaaS comparisons: Render vs Railway vs Fly.io 2026, Cadence blog