Frameworks

Astro vs Next.js for Content Sites: Which Wins

AstroNext.jsstatic sitescontent sitesframeworksperformanceSSGislands architecture

You're building a content-heavy site — a blog, documentation hub, marketing site, or portfolio — and two frameworks keep coming up: Astro and Next.js. Both can produce fast, SEO-friendly pages, but they make radically different bets about how much JavaScript your visitors should receive. This post maps out exactly where each framework wins so you can stop second-guessing and ship.

The core philosophical split

Next.js was built around React. Every page is a React component, and even when you render it at build time, the browser still downloads a React runtime and "hydrates" the page so it can respond to interactions. For a dashboard or SaaS app full of client-side state, that tradeoff is invisible. For a blog post that has one newsletter signup form, you're shipping hundreds of kilobytes of JavaScript that the reader never needs.

Astro takes the opposite stance. Pages are compiled to plain HTML by default. JavaScript only reaches the browser when you explicitly attach it to a component using an island directive (client:load, client:idle, client:visible). The result is near-zero JavaScript on pages that don't need it — which describes the majority of content pages.

This is not a minor implementation detail. It changes your Lighthouse scores, your hosting bill (fewer bytes transferred), and your developer experience when you want to pull in a React, Vue, or Svelte component without committing your whole project to one UI library.

Where Astro has a real edge

Zero-JS by default. A typical Astro blog page ships 0 KB of client JavaScript unless you add an island. Next.js ships a React runtime regardless. For pure reading experiences — articles, docs, landing pages — this matters for Core Web Vitals and, by extension, organic search rankings.

Content Collections. Astro's built-in Content Collections API gives you type-safe frontmatter validation for Markdown and MDX files. You define a Zod schema, and Astro rejects malformed entries at build time. Next.js has no equivalent first-party primitive; you reach for contentlayer, next-mdx-remote, or a headless CMS SDK and wire it yourself.

Multi-framework components. You can drop a React chart, a Vue accordion, and a Svelte animation onto the same Astro page. Each island hydrates independently. This is genuinely useful when migrating a legacy site or when your team has mixed framework preferences.

Build output simplicity. Astro's default output is a folder of .html files and assets. You can host it on any CDN — Cloudflare Pages, Netlify, GitHub Pages — with no adapter required. Next.js static export (output: 'export') exists but strips server features; the moment you need ISR or server components, you're back to a Node or Edge runtime.

Where Next.js holds its ground

App Router and React Server Components. If your content site is also a product — authenticated user dashboards, personalised feeds, commerce with cart state — Next.js App Router handles the full spectrum without switching frameworks. Astro's server-side story is improving, but it is not the primary use case.

Ecosystem maturity. Next.js has been in production since 2016. The number of tutorials, Stack Overflow answers, and third-party integrations is enormous. If your team already knows React deeply, the learning curve is flat.

Incremental Static Regeneration. ISR lets a Next.js page rebuild in the background after a set interval without a full site rebuild. For a site with thousands of pages that update frequently — a news publisher, a large e-commerce catalogue — ISR is a genuine operational advantage. Astro's equivalent is server output mode with on-demand rendering, which works but requires a runtime host.

Vercel integration. If you're already on Vercel, Next.js is the native citizen. Analytics, edge middleware, image optimisation, and preview deployments all work with zero configuration. Astro runs on Vercel too, but some features need manual adapter setup.

Head-to-head comparison

CriterionAstroNext.js
Default JS sent to browser~0 KBReact runtime (~45 KB+)
Content authoring (MD/MDX)Built-in Content CollectionsNeeds third-party library
Multi-framework componentsYes (React, Vue, Svelte, etc.)React only
ISR / on-demand rebuildVia server output + adapterFirst-class, no adapter needed
Auth & full-stack featuresLimited (growing)Mature (App Router + middleware)
Static hosting (no Node)Yes, defaultOnly with output: 'export'
Vercel native featuresPartial (adapter required)Full, zero-config
Learning curve (React devs)ModerateLow
Build speed (large sites)Fast (Vite-based)Moderate (Turbopack improving)

A decision checklist

Use this before you commit to either framework:

  • Your site is mostly read-only content (blog, docs, portfolio) → Astro. You get better Lighthouse scores with less effort.
  • You need ISR for thousands of frequently-updated pages → Next.js.
  • You want to mix React and non-React components → Astro.
  • Your site includes authenticated routes, cart state, or user-specific data → Next.js App Router.
  • Your team is React-native and wants the smallest context switch → Next.js.
  • You're hosting on a pure CDN with no Node runtime → Astro (static output is the default).
  • You need Vercel's edge middleware or analytics out of the box → Next.js.
  • You're migrating a legacy multi-framework codebase → Astro's multi-framework islands make this far less painful.

Hosting and cost implications

Astro's default static output deploys to any CDN for free or near-free — Cloudflare Pages free tier, Netlify Starter, GitHub Pages. There is no cold-start latency because there is no server. Next.js in its full form needs a Node runtime or an edge runtime, which means you're paying for compute even on quiet nights.

For a content site with modest traffic, that difference can be zero dollars in practice (Vercel's free tier is generous). But at scale — or if you're paying per-request on a serverless plan — the "ship no JavaScript" philosophy of Astro also means "run no server" for the common case, which compounds into real savings.

If you want a side-by-side look at hosting options that pair well with each framework, the /compare tool on CraftMyStack lets you stack hosting providers against each other across price, runtime support, and cold-start behaviour. And if you're still unsure which framework fits your specific project constraints, /recommend will walk you through a short questionnaire and surface a grounded suggestion.

For teams evaluating their broader workflow — not just the framework but the CMS, database, and deployment pipeline — www.craftmyflow.com maps out how tools connect into end-to-end pipelines, which pairs well with the framework decision you're making here.

Key takeaways

  • Astro ships zero JavaScript by default; Next.js always ships a React runtime. For content sites, this gap shows up directly in Core Web Vitals.
  • Astro's Content Collections give you type-safe Markdown management without a third-party library. Next.js requires you to wire this yourself.
  • Next.js wins when your site is also a product: authenticated routes, ISR at scale, and Vercel-native features.
  • Astro supports React, Vue, and Svelte components on the same page via islands — useful for migrations or mixed teams.
  • Static hosting (no Node runtime) is Astro's default. Next.js needs output: 'export' to match it, and you lose server features.
  • The right answer depends on your content update frequency, authentication needs, team familiarity, and hosting constraints — not on which framework has more GitHub stars.

Ready to map your full stack — framework, database, and host — in one place? Head to /browse on CraftMyStack to explore how Astro and Next.js fit alongside the rest of your toolchain.

Never miss a prompt breakthrough

Join 500+ builders getting focused email updates whenever we publish. Unsubscribe anytime — or follow the RSS feed.

Prefer a reader? RSS feed