← All articles

Websites Don't Need to Be Apps

Why Astro is a strong fit for content driven sites, and when its server first model pays off.

Websites Don’t Need to Be Apps

Not every website needs a JavaScript framework running in your browser. Astro takes a different approach: start with HTML, keep things simple, and add interactivity where it actually matters.

Somewhere along the way, we started treating websites like they all needed to be applications.

Frameworks, hydration, client-side rendering, state management. All useful technologies, but do we really need all of that just to display some text, images, and a few links?

There’s nothing wrong with building web applications. The problem is using the same approach for websites that don’t actually need it.

That’s what makes Astro interesting. It takes a fairly straightforward idea and builds an entire framework around it.

Start with a webpage. Add the application bits later.

HTML is still pretty good

It’s easy to forget just how much HTML can do on its own.

A blog post doesn’t need JavaScript to display its content. Neither does a documentation page, a portfolio, or most of a product catalogue.

With Astro, that’s essentially the starting point.

By default, Astro generates static HTML during the build process. When someone visits your website, they’re served a page that’s already been put together.

No client-side framework needs to initialise before the content becomes readable.

Astro components make this feel surprisingly modern, too. You still get reusable components, layouts, imports, and the other conveniences you’d expect from a modern framework.

The difference is what happens when those components reach the browser.

Astro components don’t ship a JavaScript runtime to the browser by default.

That doesn’t mean Astro can’t use JavaScript, or that every Astro website will automatically be fast. It simply means you aren’t starting with a load of browser-side work you might not need.

And that’s a pretty sensible default.

But what about interactivity?

Obviously, static HTML isn’t the answer to everything.

Maybe your blog has a search interface. Perhaps a product page needs an interactive configurator, or you’ve built a dashboard that displays live information.

These features genuinely benefit from JavaScript.

Astro handles this through something called islands architecture.

Rather than making the entire page a JavaScript application, you can turn individual components into interactive islands while everything around them remains ordinary HTML.

Think of it like this:

Part of the page Does it need JavaScript?
Article text and headings No
Images and ordinary links No
Interactive search Probably
Live data visualisation Yes
Comments widget Depends on implementation

Astro lets you make those decisions at the component level.

A small example

Imagine a blog post with an interactive search box and a comments section.

---
import SearchBox from '../components/SearchBox.jsx';
import Comments from '../components/Comments.jsx';
---

<SearchBox client:load />

<article>
  <h1>Websites Don't Need to Be Apps</h1>
  <p>Sometimes HTML is all you need.</p>
</article>

<Comments client:visible />
  • <SearchBox client:load />Search UI — interactive from page load
    JS on load
  • <article> … </article>Headings, text, images — ships as HTML
    no JS
  • <Comments client:visible />Below the fold — hydrates when scrolled into view
    JS when visible
Only the islands hydrate. Everything between them stays static HTML.

There are two interesting things happening here.

The search box uses client:load, which tells Astro to load and hydrate that component when the page loads.

The comments section uses client:visible, so its JavaScript can wait until the component approaches the visible area.

Meanwhile, the article between them is just HTML.

No React application wrapping the entire page. No need to hydrate the article itself.

You can use frameworks like React, Vue, or Svelte for these islands, so you don’t have to abandon the tools you already know.

The goal isn’t to eliminate JavaScript. It’s to stop using it where it doesn’t add anything.

One small detail worth mentioning: Astro also supports ordinary browser JavaScript. You don’t need to introduce an entire framework component just to make a button do something.

Markdown makes a lot of sense here

Another thing Astro gets right is how it handles content.

For blogs, documentation, and similar websites, Markdown is a natural fit. You can write articles as files instead of building a complicated system around storing and displaying them.

Astro’s content collections take this a little further.

You can define a collection of articles, specify what information each article should have, and let Astro validate it.

A typical article might start with something like:

---
title: "Websites Don't Need to Be Apps"
description: "Why Astro's HTML-first approach makes sense."
pubDate: 2026-11-18
tags:
  - astro
  - web-development
---

You can configure the collection to require particular fields and check that they contain the right types of data.

That means fewer surprises when publishing, and a consistent way to handle articles across the site.

Content collections can also be queried to build article listings, category pages, and other features without manually wiring everything together.

And if ordinary Markdown feels limiting, there’s MDX.

MDX lets you mix Markdown with components, opening the door to interactive examples, custom callouts, and more interesting article layouts.

For a personal blog, that’s a particularly nice combination. The writing stays straightforward, while individual articles can still do something a little different when the topic calls for it.

It’s not always the right choice

Astro isn’t the answer to every website.

If you’re building a collaborative editor, a complex dashboard, or something where almost every element is interactive, a more application-focused framework might make more sense.

You can build those things with Astro. It supports server rendering on demand and can host substantial interactive components.

But if most of your interface needs JavaScript anyway, some of Astro’s biggest advantages become less relevant.

It’s also worth remembering that using Astro doesn’t automatically guarantee great performance.

Huge images, unnecessary fonts, third-party scripts, and poorly optimised components can still make a website painfully slow.

Astro gives you a good starting point. What you build on top of it still matters.

Maybe we’ve been overcomplicating things

The funny thing about Astro is that its core idea isn’t particularly revolutionary.

Serving HTML to a browser is how websites worked long before modern JavaScript frameworks existed. Static site generators aren’t exactly new either.

What Astro does well is make that approach feel natural alongside modern web development tools.

You can build reusable components, write content in Markdown, use your favourite UI framework, and add genuinely interesting interactions without turning the entire website into an application.

For content-heavy sites, that’s a compelling balance.

There’s nothing inherently wrong with web apps. Some of the best things on the internet wouldn’t exist without them.

But not everything needs to be one.

Sometimes a website can just be a website.


Further reading

← More articles
Pages & writing