I'm a big fan of modern static websites, especially when they're paired with source control and a good automation pipeline. They're cheap to host, they're fast, they're secure, and they give you a lot of the same content management capabilities you'd get from a database-driven system — just without all the complexity and maintenance headaches that come with one. Bridgetown is my static site generator of choice right now, and I'm a big fan of GitLab for their source control and automation capabilities.
Enforcing a Design System
Most web designers don't love giving content authors complete control over what a page looks like. Give someone a rich text editor and they'll change the font, bump up the heading size, pick a color that's close-but-not-quite the brand color, and generally have a great time making a mess of things. That's not a knock on content authors; it's just what happens when you hand someone a toolbox without guardrails. This is why I use Markdown, ASCIIDoc, or a simple WYSIWYG editor for content — tools that let people write well-structured content without giving them enough rope to accidentally undermine the design. If it's just me writing, I'll often work directly in HTML, but I'll reach for these simpler formats when I have longer documents to work through.
Branch, Merge Request, and Approval Workflows
Source control tools like GitLab and GitHub give you a really clean workflow for managing changes to your site. The basic idea: you make a copy of the site as it currently exists, make your changes in that copy, and then submit those changes for review before anything goes live. Reviewers can leave comments, request changes, and approve the update — and nothing gets published until it's gone through whatever review process you've set up. When you're ready, you merge the changes in and the site rebuilds automatically.
This is genuinely useful beyond just catching typos. GitLab's code owner feature, for example, lets you require that specific people sign off on changes to specific parts of the site — so your legal page can't go live without someone from leadership approving it, or your homepage can't change without a designer reviewing it first. It's a lightweight but surprisingly effective governance tool.
Reusable Components
Most website builders can technically do reusable components — but it usually involves hunting through a plugin library, hoping someone has built what you need, and then figuring out why it's half-broken on mobile. Static site generators handle this natively, and it's as easy as dropping in a reference to a partial file.
In practice, this means things like your navigation, footer, alert banners, call-to-action blocks, and event listings can all live in one place. When you need to update them, you update one file and every page that uses that component reflects the change automatically. No hunting through 40 pages to make the same edit by hand. And because this works the same way whether you're writing HTML, Markdown, or ASCIIDoc, content authors can drop these components into their pages without needing to understand how they work under the hood.
Structured Data
The ability to pull in and work with structured data is one of my favorite things about static site generators like Bridgetown. I can create JSON or YAML files as part of the site itself, or connect to external sources like a headless CMS or a Google Sheet, and reference that data anywhere on the site — or even use it to automatically generate entire sets of pages.
A practical example: a staff directory page that automatically builds itself from a simple data file, so adding a new team member is just a matter of adding a few lines to a YAML file. Or an event listings page that pulls from an external calendar feed. You can also attach custom data directly to individual pages — publish dates, authors, categories, related links, anything you want — and reference it in layouts, navigation, or other pages without any extra configuration.
Ease of Hosting
Static websites are just plain files - so they can be hosted pretty much anywhere. This means that you can host them on super cheap shared hosting plans or tiny VPS instances, on an old Raspberry Pi sitting in your basement, or even for free on services like GitHub Pages or GitLab Pages. You don't need to worry about database servers, server-side scripting languages, or any of the other complexities that come with hosting dynamic websites. This also means that static websites are faster and more secure, since there are fewer moving parts and very little actual work required to generate pages.
Ease of Migration
Static sites are unusually easy to migrate — in both directions.
Coming from another platform? Static site generators work with plain HTML, so bringing in content from an existing site is often as straightforward as grabbing the HTML source, cleaning it up, and dropping it in. There are also import tools for many popular platforms (WordPress especially) that can do a lot of the heavy lifting automatically.
Leaving for something else? Because your content is stored in plain text files — HTML, Markdown, or ASCIIDoc — it's not trapped in a proprietary database format. If you ever decide to move to a different static generator, the tools tend to work similarly enough that the transition is usually a matter of reorganizing a folder structure and updating a config file. And if you decide to move to a traditional CMS down the road, your content is already in a format that's easy to import. You're not locked in.
This is the approach we use for all of the websites we build at Sledgehammer Infosystems. If you're curious whether it might be a good fit for your organization — or if you're dealing with a site that's become more trouble than it's worth — here's more about how we work.