The last thing you ever want is a CMS that gets in your way. That’s been the guiding principle for De Voorhoede, the fine folks from the Netherlands who're the faces behind some incredible projects like Life Terra, Computed Fields, and Word Counter.
Notice something there? There's plugins. Ooh yeah, these peeps have been CHURNING out super helpful plugins to extend DatoCMS, and between their community and private ones there's easily 15+ floating around in the wild. And obv, to do things like that, they need a CMS that adapts to their needs, not the other way around.
Which is why, DatoCMS is their go-to choice, not just because of our flexibility, but because of how the CMS fits seamlessly into their workflows. From modular content structures to APIs with a great DX, they have the freedom to build without limitations.
But De Voorhoede doesn’t just stop there. They extend, optimize, and automate everything. That’s where their work on DatoCMS plugins and head-start comes in.
So let's dive into the whats and the whys behind what they've been cooking 👇
Let's make it about us
So what is it about DatoCMS that makes De Voorhoede coming back?
They needed something flexible, API-first, and easy to integrate with any frontend framework. Textbook definition of a Headless CMS innit. That’s what led them to us.
Unlike traditional CMS platforms (note: most of their earlier clients are from the WordPress category of CMS), it didn’t dictate how the frontend should be built. The separation between content management and content delivery was clean. Editors got a powerful yet simple interface, while developers had a GraphQL-powered backend that could fit seamlessly into any stack.
One of the biggest reasons De Voorhoede stuck with DatoCMS was the approach to content structuring. Unlike other CMS platforms that impose rigid templates, DatoCMS introduced modular blocks and structured text, which allowed them to model content however they needed.
For projects with highly dynamic layouts, blocks provided a flexible, reusable system, letting editors build pages using predefined components without sacrificing consistency. Structured Text took it even further, making rich content more portable and API-friendly, while still giving editors an intuitive writing experience.
I think you were one of the first CMSs to offer the modular blocks and quickly following with the structured text. And those two combined are just so powerful to basically build whatever you want. And then of course all the other fields around that are nice.
This combination of developer flexibility and editorial control meant they could build whatever they wanted. Whether they were creating standard marketing pages or complex, data-driven apps, everything adapted to their needs—not the other way around.
The DX also played a big role. The mental model behind DatoCMS felt natural to work with, making it easy to structure content in a way that felt right for both developers and editors. Image optimization, modular content blocks, and structured text were built-in and "just worked". De Voorhoede didn’t need to waste time hacking together solutions for things that should be standard in a modern CMS.
What attracted us further is the developer experience. The whole mental model around DatoCMS, the APIs, the SDK—everything just clicks.
Ok but enough about us 💁♀️ Back to Jasper.
What really set DatoCMS apart was its extensibility, and that’s where De Voorhoede started pushing the limits, building custom plugins and eventually developing head-start, an open-source repo that streamlines the integration between DatoCMS and frontend frameworks. Let's talk about that.
Let's talk Plugins first
DatoCMS does a lot out of the box, but we also walk a fine balance between default features offered to stay at "just enough" without venturing into "feature bloat". But every project has unique requirements. Which is why we encourage the use of Plugins.
This is where De Voorhoede shines - they built plugins to fill the gaps that every project (or several) needed, tweaking the CMS to offer custom functionalities. Over time, they became one of the most active contributors to the DatoCMS plugin ecosystem, creating both public and private extensions to enhance editor workflows.
Their public plugins solve common challenges like computed fields, SEO optimization, and AI-assisted content generation. One of their (and ours) favorites is the Computed Fields plugin, which functions like Vue’s computed props, allowing certain fields to generate dynamic values based on existing content.
What I personally love is our computed fields plugin. It’s like computed props in Vue - it lets us dynamically generate values that the API doesn’t store by default.
But some of the most powerful work happens behind the scenes with private plugins. For Life Terra, a platform that tracks tree planting, they built a Mapbox-based plugin that lets editors draw regions directly inside DatoCMS. Instead of requiring a separate admin tool, they embedded this functionality into the CMS itself, letting content editors manage geolocation data without ever leaving their content workflow.
One of the coolest private plugins we built was for Life Terra. Editors could draw a region in the CMS using Mapbox, defining where trees could be planted. That data gets saved as JSON and used in the app.
They also built an AI-powered content importer that scrapes content from external sources and auto-fills fields in the CMS. Instead of manually copying and pasting, editors can simply paste a URL, click a button, and have key data extracted instantly.
Combining AI with DatoCMS has been a game changer. Instead of manually entering content, we built a plugin where an editor pastes a URL, and AI extracts and structures the content into the right fields.
The motivation behind all this work is simple: make the editor experience seamless and reduce friction in content management. If something takes multiple steps when it could take one, it’s a problem worth solving for them.
Honestly tho, we could go on about how useful these plugins are, but if you're working on projects and need the CMS to do just that little bit more, check out the stuff they've published!
But what good is a fully beefed up CMS if they've to spend hours replicating the work they do over and over again for each client right? Jasper's got a solution for that too. head-start. It's an OSS approach to whipping up new projects that rely on DatoCMS, connecting to any frontend framework to speed up the dev process. So let's dive into that.
With our powers combined
After working on dozens of projects with DatoCMS, De Voorhoede realized that the first few weeks of every project looked the same. The same foundational setup—configuring SEO, localization, structured content, and routing—had to be repeated over and over.
Instead of reinventing the wheel each time, they built head-start, an open-source repo that connects DatoCMS to frontend frameworks in a structured and repeatable way.
With head-start, devs get a pre-configured environment with best practices already in place. SEO, routing, internationalization, and content models are all set up automatically, so teams can jump straight into building unique features instead of handling boilerplate.
With
head-start, we can generate a new project, run a script, and instantly have a structured setup with DatoCMS and a frontend framework of our choice.
One of the best parts of head-start is that it’s framework-agnostic. While Next.js and Vercel are a common pairing for DatoCMS projects, De Voorhoede has leaned towards Astro and Cloudflare Pages because of their performance benefits and closer adherence to web standards. But they've kept the package to be relatively agnostic, letting you work with any JS SPA framework, giving you the flexibility to choose what works best for you.
Another sweet feature is preview mode. While Next.js offers a built-in solution for previewing content (+ Vercel Content Link when paired with Vercel), Cloudflare required a touch more work. Instead of trying to force static regeneration for previews, De Voorhoede built a separate deployment branch that renders pages dynamically, making preview mode seamless for editors.
At the end, for De Voorhoede, a good CMS setup isn’t just about content management—it’s about making life easier for both editors and developers.
After working on so many DatoCMS projects, we noticed that 80% of the setup was the same—SEO, routing, localization, structured content. That’s why we built
head-start.
Editors should be able to jump in and start using the CMS without requiring a training session. Instead of cluttering the interface with unnecessary complexity, they focus on creating a natural editing experience. Inline documentation, tooltips, and well-structured content models eliminate the need for long user manuals.
Clients always ask, ‘How long is the CMS training?’ Our answer is ‘None.’ If the CMS is well-structured, it should be intuitive from day one.
For devs, head-start removes a huge amount of setup work. The repo includes prebuilt GraphQL queries, SEO-ready components, and localization logic, so they don’t have to set it up manually. They’ve even integrated PLOP.js that lets developers auto-generate new components and GraphQL fragments with a single command.
For developers, we added automation to
head-start, like PLOP.js, which generates GraphQL queries and UI components with a single command.
Seriously, its' pretty damn cool.
What's coming up?
As with any OSS project, maintenance is always a talking point. maintaining head-start is a balance. De Voorhoede is realistic about what they can maintain long-term, so they focus on features they actively use in production.
Right now, their short-term roadmap includes improving content collections and tagging, making it easier to filter and organize large amounts of content. They’re also working on AstroDB integrations, ensuring that the content layer stays perfectly in sync with the frontend.
Longer-term, they see head-start evolving beyond just websites. They’re exploring ways to make it work for app development, integrating with databases for handling more complex relational data. The goal is to create a setup where DatoCMS handles structured content, while a separate database manages user-generated content and application data.
The TLDR on head-start really shows how they handle CMS projects strategically instead of reactively, Instead of treating every project as a unique challenge, they’ve built repeatable solutions that make content management faster, smoother, and more scalable, and easier to tweak to the bespoke little quirks that each project requires.
And because they openly share their tools, other teams don’t have to start from scratch. Whether you use the entire head-start setup or just borrow individual ideas, there’s no need to reinvent the wheel.