cheapstack
RSSBrowse stacks
framework / 06 — updated may 2026

SolidStartby solid.js team

The fine-grained-reactive metaframework. SolidJS's runtime is so small it almost doesn't feel like a framework, and SolidStart wraps it in a Next.js-shaped full-stack experience. Niche, but the best DX in this set if you can stomach the smaller ecosystem.

languageTypeScript-first
runtimeNode · Vinxi · edge adapters
renderingSSR · SSG · CSR · streaming
coreSolid 1.9 (May 2025)
Skip to verdictSee pricing →
verdict.txt — frameworks/solidstart.mdhonest
$cat verdict.txt

Pick SolidStart if you've felt the pain of React's re-render model and want fine-grained reactivity without rewriting in another language. Skip it if your team needs the ecosystem reach of React or Vue.

Updated May 2026read the full reasoning →
verdict / bull case + bear case

Why we picked it — and why we might not

SolidStartis the default React framework in 2026 not because it’s the smallest or the simplest, but because it’s the one with the least friction across the widest set of problems — provided your problem is shaped like a React product on Vercel.

The bull case is straightforward. App Router, Server Components, and Server Actions collapse what used to be three layers (page, API route, client fetcher) into one mental model. The Vercel deploy story is unmatched — push to git, get a preview URL, promote on click. The ecosystem is the largest in React: every auth provider, every database client, every UI library has a first-class SolidStart example, and the AI assistants understand SolidStart better than they understand any other framework. For a team that’s already on React, choosing SolidStart means choosing the path with the most documentation, the most third-party integrations, and the most worked examples.

The bear case is also real. The cache model is the most complex in the ecosystem; newcomers fight it before they understand it, and “wait, is this server or client?” is a permanent confusion for the first month. Bundle size meaningfully exceeds Astro and SvelteKit — fine if you’re using RSC, pure overhead if you’re not. Lock-in is medium-strength: ISR-on-demand, image optimization, and middleware all bind tighter to Vercel-style hosts than to a generic Node server. Self-hosting works, but you trade deploy ergonomics for it.

For most product teams the calculus comes out in SolidStart’s favor, but the failure modes are specific and worth naming. If your app is a SPA, Vite + React Router ships less code. If your site is content-first, Astro is a better fit. If you need a pure backend, Hono or Fastify are the right answer. The honest summary: SolidStart is the right default, not the right answer in every case.

scoreboard / at a glance

At a glance

One row per dimension. The value is what SolidStartgives you; the note is the editorial framing — the quiet caveat that the marketing page won’t mention.

Routing
file-system · src/routes · nested layoutsConvention-driven, similar to SvelteKit. Solid Router under the hood.
Rendering
SSR / SSG / CSR / streaming · per-routeHybrid rendering with explicit per-route control. Streaming via Solid's built-in Suspense.
Reactivity
fine-grained signals · no virtual DOMHeadline differentiator. Updates target specific DOM nodes, not component re-renders.
Data fetching
createAsync / cache / action — typed, server-awareFunctional patterns for server-side data. Less ceremony than Next.js's RSC + use-client model.
Server (Vinxi)
API routes via /server · Vinxi-poweredBuilt on Vinxi (a meta-meta-framework runtime). Adapter coverage spans Node, Vercel, Cloudflare, Deno, Bun.
Bundle size
smallest in this comparison set · ~7KB Solid runtimeSolid's runtime is dramatically smaller than React or Vue. SolidStart benefits directly.
Hosting fit
Vercel · Cloudflare · Netlify · Node · Deno · BunAdapter coverage is solid (no pun). Fewer hosts than Nitro but covers the major ones.
Ecosystem
smaller than Vue's · smaller than Svelte'sThe smallest active ecosystem in this set. UI libraries, auth integrations, and tutorials are limited.
Lock-in
low · adapter-based deploy · no proprietary cacheHighly portable. The framework is small enough that there's not much to lock you in.
Framework age
5 years (Solid) · SolidStart 1.0 (Apr 2024)Solid is mature; SolidStart 1.0 is recent. Production deployments exist but the framework is younger than Next.js / Nuxt / SvelteKit.
pricing / three scenarios

Pricing at three scales

Three receipts at three traffic shapes. Numbers are illustrative — list-tier prices from May 2026, rounded to the dollar. Nothing here is invented; actual bills will vary with usage shape.

hobby.txt — 1k MAU · weekend projectmonthly
line itemdetailcost
HostingCloudflare Pages — freefree
DatabaseTurso free tierfree
TOTAL · monthlyfree/mo
>SolidStart on Cloudflare is free and ships very small bundles — the cheapest credible production stack with the smallest JS payload of any framework in this set.
side-project.txt — 10k MAU · steady traffic · paying customersmonthly
line itemdetailcost
HostingCloudflare Pages — freefree
DatabaseTurso Scaler$9
BandwidthCF Pages — unlimited freefree
TOTAL · monthly$9/mo
>Same economics as SvelteKit / Astro / Remix at this scale. The smaller bundle is essentially free to host on Cloudflare's bandwidth-included pricing.
scale.txt — 100k MAU · production · multi-regionmonthly
line itemdetailcost
HostingCloudflare Pages · global edgefree
BandwidthCF Pages · unlimited freefree
DatabaseTurso Production · 8 replicas$29
WorkersCF Workers paid$5
TOTAL · monthly$34/mo
>Identical scale economics to SvelteKit / Astro / Remix. Different framework, same hosting reality: Cloudflare-Pages-shaped deploys collapse the bill at high traffic.
features / deep dives

Feature by feature

Six rows. The body describes how the feature works in 2026; the honest tradeoff is the part the docs won’t tell you. Skim the bold lines if you’re in a hurry.

01

Fine-grained reactivity

no virtual DOM, no re-renders

Solid uses signals (createSignal) and computed values (createMemo) to track exactly which parts of the DOM depend on which state. When a signal changes, only the dependent DOM nodes update — no component-level re-render, no diffing.

Honest tradeoff

The performance is genuinely better than React for high-frequency updates (real-time dashboards, animations, fast inputs). The downside: the mental model is different from React/Vue, and it takes a week to internalize.

02

createAsync / cache

data fetching with server-side primitives

createAsync wraps an async function and integrates with Suspense for streaming. cache(fn) memoizes a server function so multiple components share one fetch per request. Combine them for typed, deduplicated, streamable data flows.

Honest tradeoff

More primitive than Next.js's RSC + caching system, but explicit about what runs where. Smaller surface area to learn; no implicit cache invalidation magic.

03

Actions

type-safe form mutations

action() wraps a server function for use in <form action=...> or imperative calls. Returns are type-safe; useSubmission exposes pending state. Same shape as Remix actions, smaller framework.

Honest tradeoff

Excellent ergonomics for form-heavy apps. The downside: documentation is thinner than Remix's, so you'll often read source to confirm behavior.

04

Vinxi runtime

the meta-meta-framework underneath

Vinxi is a small "meta-framework framework" that handles routing, build orchestration, and adapter integration. SolidStart sits on top of Vinxi; other frameworks (TanStack Start) also use Vinxi. The abstraction lets SolidStart inherit a wide adapter ecosystem cheaply.

Honest tradeoff

Vinxi is genuinely useful for adapter coverage. The downside: an additional layer to debug when something goes wrong — your error trace might cross SolidStart → Vinxi → adapter.

05

JSX (with a twist)

looks like React, behaves like Solid

Solid uses JSX, so React devs feel immediately at home — until they realize components run only once and signals are the reactivity primitive. Conditionals are <Show>, lists are <For>, not {cond && ...} or {arr.map(...)}.

Honest tradeoff

JSX familiarity is a real onboarding accelerator. The conceptual leap (single-execution components) is the surprising part — fight it for the first day, internalize it, then it's faster than React forever.

06

Streaming + Suspense

out-of-order HTML streaming

SolidStart streams HTML out-of-order using <Suspense> and createAsync. Slow data doesn’t block fast data; the page renders progressively. Same architectural pattern as React Server Components, with a simpler model.

Honest tradeoff

Streaming works without RSC's complexity. The downside: documentation on advanced streaming patterns is thinner; you'll figure out edge cases by experimentation.

fit / use or skip

Use it for, skip it for

use / solidstart

Use SolidStart for…

  • Fine-grained reactivity is genuinely valuable to your product — high-frequency updates, real-time dashboards, animation-heavy interfaces.
  • Bundle size matters and you want smaller than SvelteKit, smaller than React, smaller than Vue.
  • JSX familiarity is a soft requirement — your team can read React code; that translates to Solid faster than to Svelte or Vue.
  • You're building a small-to-mid-sized product where the smaller ecosystem isn't a blocker.
  • Performance for a specific use case (canvas-heavy, audio-visual, real-time) is the deciding factor.
skip / solidstart

Skip SolidStart for…

  • Your team is large, hires from a job market that's React/Vue dominant, and ecosystem reach matters more than bundle size.
  • You need niche libraries that exist only in React (specific UI kits, charting libs, third-party widgets).
  • AI-assisted code generation is heavily used — Claude/Copilot are noticeably better at React, Vue, even Svelte than at Solid.
  • You're allergic to the smaller ecosystem and the prospect of writing more from scratch when off-the-shelf solutions don't exist.
  • You're building a content-first site — Astro is a better fit than any app-shaped framework.
gotchas / observed

Gotchas worth knowing

Six pitfalls visible in public docs and community discussion. None will stop you shipping; all of them will cost you an afternoon if you don’t know about them.

  • SolidStart / components

    Components run once — destructured props don't track

    A common React-mind error: function ({ count }) { return <span>{count}</span> }. Destructuring loses reactivity in Solid because the component runs once. Use props.count or wrap with splitProps. The behavior is by design; the bug is universal among Solid newcomers.

  • SolidStart / lists

    Array.map() in JSX recreates DOM nodes; <For> doesn't

    {items().map(...)} works but creates / destroys DOM on every change. <For each={items}>{(item) => ...}</For> reuses DOM nodes via key-based reconciliation. The performance difference is significant for long lists.

  • SolidStart / SSR

    Browser-only APIs in components break SSR silently

    Calling window or document at the top level of a component crashes SSR. Wrap in onMount or check isServer. The error message often points at JSX rather than the offending call.

  • SolidStart / hydration

    Hydration mismatches manifest as broken signals

    If server-rendered HTML doesn't match the client's first render, signals get out of sync — clicks fail to update the DOM, with no console error. Audit createAsync calls for environment-dependent paths.

  • SolidStart / actions

    Action results need explicit revalidation

    After an action runs, dependent createAsync calls don't auto-revalidate. Use the action's `revalidate` option or call `revalidate()` explicitly. Easy to miss; bites on dashboard-shaped apps after a mutation.

  • SolidStart / docs

    Tutorial content is thinner than Next.js / Nuxt

    The framework is solid; the surrounding tutorial / blog ecosystem is small. When you Google a question, you'll often land on a 2023 article from before SolidStart 1.0. Always check the date and the SolidStart version when following external guides.

how it compares / different bets

How it compares

Three short framings. No clear-winner declarations — these are different bets, and the right pick is mostly a question of what you’re optimizing for. Linked comparison pages have the side-by-side detail.

SolidStart ━▶ React/Next.jsdifferent bets

Next.js bets on the largest possible ecosystem and the gravitational pull of React. SolidStart bets on a smaller, sharper runtime with fine-grained reactivity. Next.js is the safer career-and-team-scaling choice; SolidStart is the better-performing choice for specific workloads.

Pick Next.js for typical product builds where the React ecosystem's depth is the deciding factor. Pick SolidStart when fine-grained reactivity, smaller bundles, or specific high-frequency-update use cases are the deciding factor.

SolidStart ━▶ SvelteKitdifferent bets

SvelteKit's compiler ships less JS than SolidStart for simple components, but Solid's signals beat Svelte's reactivity for high-frequency updates. The frameworks are architecturally similar — file-system routing, hybrid rendering, server endpoints — and differ mostly in their reactivity primitives.

Pick SvelteKit for the larger Svelte ecosystem and slightly smaller bundles in the typical case. Pick SolidStart for the better fine-grained-reactivity story and JSX familiarity.

SolidStart ━▶ Qwikdifferent bets

Qwik bets on resumability — the page is ready interactive without hydration. SolidStart still hydrates, but with much less JS than React. The two are the most performance-experimental frameworks in this set.

Pick Qwik when avoiding hydration entirely is the goal (especially for high-traffic content sites). Pick SolidStart when JSX-familiar fine-grained reactivity beats Qwik's harder-to-internalize resumability model.