At ScatterSpoke, we’re all about continuous improvement—it’s at the core of what we help teams achieve through better retrospectives. So when it came time to rebuild our own website, we knew we needed to practice what we preach and make meaningful improvements based on what we’d learned.
After evaluating our options, we chose Astro, and the results have been transformative. Here’s why we made the switch and what we learned along the way.
Our previous website worked, but it had limitations that were holding us back. We needed a solution that would give us:
Lightning-fast performance. Our users are busy engineering leaders and team members who don’t have time to wait for slow-loading pages. And SEO still matters. We needed a framework that prioritized speed without sacrificing functionality.
Better content management. With our growing library of retrospective formats, blog posts, and resources, we needed a system that made it easy for our team to create and manage content without wrestling with complex build processes or performance optimization.
Modern developer experience. We wanted to use the same modern tools and workflows that make ScatterSpoke app development enjoyable and efficient, while still allowing us to iterate quickly.
Component reusability. As we scale our content and features, we needed a system that would let us build once and reuse everywhere.
Astro checked all these boxes and more.
What makes Astro special is its Islands Architecture. Unlike traditional frameworks that ship JavaScript for everything, Astro only sends JavaScript for the interactive components that actually need it. The rest of your page? Pure, fast-loading HTML and CSS.
For a content-heavy site like ours, this was game-changing. Our blog posts, retrospective format guides, and informational pages load instantly because they’re just HTML. Interactive elements like our navigation, search functionality, and CTAs get the JavaScript they need—nothing more.
One of our favorite features has been Astro’s first-class support for MDX. We can write our blog posts and retrospective guides in Markdown (which is simple and portable), but when we need something more sophisticated, we can seamlessly integrate React components.
For example, in our retrospective format guides, we can embed interactive elements, custom layouts, or specialized formatting without leaving the comfort of our Markdown files:
import Button from "@components/ui/button.astro";
## Traditional Retro Board Template
The most appropriate retro board layout depends on your team's maturity...
<Button>Try This Template</Button>This flexibility means our content team can focus on writing great content, while our developers can build reusable components that enhance the user experience.
The performance improvements have been substantial. Our Lighthouse scores went from as low as 70 to consistently hitting high 90s-100 across all metrics.
Here’s what contributed to these gains:
Zero JavaScript by default. Pages load as static HTML unless they specifically need interactivity.
Optimized asset handling. Astro automatically optimizes images, bundles CSS efficiently, and handles code splitting.
Smart caching. Built-in optimization for browser caching means repeat visitors get an even faster experience.
These improvements aren’t just vanity metrics—they translate to better user experience, improved SEO, and ultimately, more teams discovering how ScatterSpoke can help them improve.
From a development standpoint, Astro has been a joy to work with:
File-based routing. Creating a new page is as simple as adding a file to the pages directory. No complex routing configuration needed.
Component flexibility. We can use Astro components, React components, or even mix frameworks if needed.
TypeScript support. Full TypeScript support out of the box means we catch errors early and ship with confidence.
Fast refresh. Development builds are incredibly fast, making the feedback loop tight and productive.
We organized our content using Astro’s content collections, which provide type-safe content management. Our structure looks like this:
src/
content/
blog/
└── [blog posts in MD/MDX]
retros/
└── [retrospective formats in MD/MDX]Each collection has a schema that ensures consistency. For our blog posts, we defined fields like title, snippet, category, author, and tags. This means we can’t accidentally publish a post without required metadata—the build will fail if something’s missing.
When we started this project we chose the AstroShip Pro theme for our website. Our old site included our main website content, landing pages, blog, and knowledge base.
Astroship Pro turned out to be a perfect choice for the the first three. But when it came to our Knowledge Base we needed something different.
Enter Starlight. Starlight is built with Astro too, giving us all the same benefits. Plus it has all of the features you expect in a great documentation site. It’s a perfect fit.
Start with content structure. We spent time upfront defining our content schemas and collection structure. This paid dividends as we migrated content and built new features.
Embrace static generation. For a primarily content-focused site, static generation is the right choice. It’s faster, more secure, and scales effortlessly.
Don’t over-optimize early. Astro is fast by default. Focus on good content first, optimize where metrics show it’s needed.
There’s probably a theme for that. There are numerous Astro themes. Find the themes that give you the best experiences and combine them. It’s worth it to have one great tech stack.
MDX is powerful, but use it judiciously. While MDX is great, we found that keeping most content in simple Markdown and reserving MDX for special cases makes our content more portable and easier to manage.
Since launching our new Astro-based website:
More importantly, we’ve created a foundation that will scale with us as we continue to grow and add new features to help teams improve through better retrospectives.
This rebuild wasn’t just about adopting new technology—it was about continuous improvement, the same principle we advocate for in retrospectives. We identified what wasn’t working, explored our options, and made changes that would genuinely improve our product.
And just like we tell teams using ScatterSpoke, the work of improvement never stops. We’re already planning the next iteration: enhanced search functionality, interactive retrospective format demos, and deeper integrations with our core product.
If you’re considering Astro for your next project, especially if you’re building a content-focused site that needs to be fast and developer-friendly, we highly recommend it.
Ready to see continuous improvement in action? Sign up for ScatterSpoke and start running more impactful retrospectives with your team.