Introduction
After years of building and maintaining websites with a variety of tools and frameworks, the need for a new personal website felt like the perfect excuse to look for something new — a framework that could tick off as many of my requirements as possible.
The goal was clear: a clean, fast, and sustainable website.
That search led me to Astro, a modern frontend framework that combines the best of static site generation with the flexibility of component-based design.
In this article, I’ll walk you through why I chose Astro for my own website, what problems it solved, and what trade-offs I considered along the way.
The Challenge: Balancing Speed, Simplicity, and Sustainability
Like many developers, I wanted a website that was fast, minimal, and maintainable — but also flexible enough to grow over time.
I explored frameworks like React and Next.js. They’re powerful tools, but they often require keeping way too much code around at runtime — most of which never gets used.
I tend to exaggerate a bit when it comes to minimizing payloads.
My rule of thumb: serve the browser only what it truly needs.
So the question became:
How can I build a site that’s beautiful, blazing fast, and future-proof — without the usual complexity?
Discovering Astro
Many years ago, I built my first website using nothing but a text editor.
It gave me complete control over the result — but it was, of course, a pain to maintain.
Over time, I moved on to content management systems and frameworks, which made development easier but came with a runtime cost.
So I started looking for something that would make my life easier at build time, while still rendering clean, lightweight pages for deployment.
That’s when I came across Astro while exploring new static site generators.
My first requirement was simple: generate a clean, fast, content-focused website. Reading into Astro, it felt like a promising framework.
- Zero JavaScript libraries by default
- Content-focused architecture
- Markdown support
- File-based routing
- Heavy lifting is done at build time
On its homepage, Astro promised content-driven websites, zero unnecessary JavaScript, no vendor lock-in, and excellent Core Web Vitals.
One of the first things that stood out after switching to Astro was how fast the site felt — not just on paper, but in real use.
Pages load almost instantly, and interactions remain smooth because no unnecessary JavaScript is blocking the main thread.
In Astro, components render to static HTML by default, and client-side JavaScript is only loaded when I intentionally add it.
That means I can write articles about React, Next.js, or Vue components (or explore new frameworks) and seamlessly use real components without shipping the entire framework.
The expected result?
A site that scores near-perfect on Core Web Vitals, requires minimal bandwidth, and keeps both search engines and visitors happy.
I’ve always believed that performance isn’t just about numbers.
Like the idea behind Core Web Vitals, I see performance as something user-experience-based rather than purely technical.
Besides, I started coding on a Commodore 64 — you learn to be frugal when you only have 32 KB at your disposal.
Developer Experience: Clean and Predictable
When comparing Astro to frameworks like React or Next.js (which I really like), the developer experience might not feel dramatically different, and that’s a good thing.
You still structure your project in reusable components, write clean functions, and automate tasks the way you’re used to.
The real difference lies in what happens after you hit build.
Astro takes that same familiar workflow and produces clean, minimal HTML, without leaving any framework traces behind.
No client-side bundle you didn’t ask for, no hidden runtime, no extra overhead. Just the output you meant to create.
It allows me to keep the convenience of a modern framework without shipping the framework itself. That balance between developer freedom and runtime simplicity is what makes Astro so elegant to work with.
Trade-offs and Limitations
No framework is perfect, and Astro is no exception (although I’m currently in the “oh wow!” phase).
While it delivers outstanding performance and simplicity, there are still a few areas worth keeping in mind.
Because Astro is relatively new, its ecosystem is still growing. Compared to older frameworks, you might find fewer plugins or third-party integrations.
However, when I browse through their showcase pages, it feels like this isn’t a major problem.
An area that stands out, and might come with a slight learning curve, is Astro’s Island Architecture, the concept that allows static pages to include interactive components where needed.
It sounds like a powerful idea, but I haven’t explored it in depth yet. I plan to dive into it and share my findings in a future article.
For now, my use case is mostly content-driven and static, which is exactly where Astro performs best.
Conclusion
At the moment, I love Astro! It fits my needs perfectly and is very beginner-friendly.
If you’ve worked with React, Next.js, or Vue before, you’ll likely have no trouble getting your first basic website up and running in no time.
Astro combines performance, simplicity, and modern development practices in a way that makes building websites both enjoyable and efficient. Its static-first approach ensures fast loading times, minimal bandwidth usage, and clean, lightweight pages.
The showcase sites suggest that building more complex functionality shouldn’t be a problem, though I plan to explore that myself when I encounter my first real challenges.
For now, I would absolutely recommend giving Astro a try, especially if you’re new to building websites and want to learn a modern, approachable framework!