Why I built my own blog engine in Next.js (instead of WordPress or Ghost)

When you decide to start a blog in 2026, the world's first reaction is predictable. "Use WordPress", "set up Ghost", "try Substack". And that makes sense, because those platforms have been solving the same problem for years, and they do it reasonably well.

We evaluated all of them. In the end, we decided to build our own from scratch. Not on a whim, but because every platform forced us to choose between what we wanted to do and what they would let us do.

What we needed wasn't a generic blog

The goal was never just "to have a blog". It was to have a technical space where we could publish articles with highlighted source code, terminal blocks, comparison tables, optimized images, and connected post series. All of that with an admin panel that didn't force us to touch FTP or install sixteen plugins.

We also wanted full control over the reader experience. No invasive cookie banners, no unnecessary third-party scripts, no load times that make you wonder whether the page has died. And real SEO, not the kind of SEO where you "install Yoast and pray".

The problem with WordPress

WordPress is still the most popular CMS in the world, and that says a lot about its flexibility. But it also says a lot about its technical debt. To get a blog with good performance, highlighted code, and a decent editor, we needed at least half a dozen plugins. Every plugin is a dependency that can break, have vulnerabilities, or stop being maintained.

On top of that, WordPress uses PHP and MySQL. We have nothing against either one, but our day-to-day work revolves around TypeScript and Node.js. Maintaining a completely different stack just for the blog felt like an unnecessary context-switching cost.

And then there's security. WordPress is the number one target for automated attacks on the web. Not because it's insecure out of the box, but because its popularity makes it a magnet. Keeping it updated, patching plugins, and watching for code injection is ongoing work we preferred to avoid.

Ghost, Astro, and modern alternatives

Ghost was the option that came closest to convincing us. It's elegant, fast, and has a clean editor. But its memberships and newsletter model are so tightly built into the core that the blog feels incomplete without those features. On top of that, self-hosting Ghost requires Node.js with MySQL, and the setup isn't trivial when you want to customize beyond what the theme allows.

Astro is brilliant for static sites, but our blog needed an admin panel with authentication, a WYSIWYG editor, drafts, scheduled publishing, and full-text search. That fits better with a server-side application than with a static generator.

There are more options, of course. Hugo, Eleventy, Jekyll. They all have their niche. But they all forced us to work with Markdown files in a Git repository, compile the site, and deploy it. For a personal blog that can work, but for a workflow where we want to write, preview, schedule, and publish from any device, it wasn't enough.

The decision to build from scratch

After evaluating the options, the conclusion was surprisingly clear. We needed a blog that worked like a full web application, with the stack we already know. Next.js gave us the framework, SQLite gave us the database without having to manage an external server, and Docker let us package everything so we could deploy it wherever we wanted.

The upfront investment was bigger, no question. But in return we got something no platform could fully give us.

• Full control over the experience. From security HTTP headers to the exact RSS feed format, everything is ours.
• An editor that works the way we want. With native support for code, tables, images from our own gallery, and AI assistance for writing.
• Zero external dependencies. No managed databases, no third-party CDN for basic functionality, no plugins to update every week.
• A real lab. Every blog feature is a chance to learn and experiment with technologies we later apply to other projects.

The real cost of "building from scratch"

We should be honest. Building a blog from scratch takes more time than you think at first. The first few weeks were fast, because the basic skeleton (posts, categories, editor) comes together fairly quickly with Next.js and Drizzle ORM. But then the details show up, the ones that make the difference between a prototype and something you can actually use.

The RSS feed, the dynamic sitemap, automatically generated Open Graph images, full-text search, the revisions system, security headers, rate limiting. All of that adds up to weeks of work that WordPress gives you out of the box with a couple of plugins.

The difference is that by building it ourselves, we understand every line. When something breaks, we know where to look. When we want a new feature, we know exactly where it fits. And when a vulnerability shows up, we don't depend on a third party to publish a patch.

Who this makes sense for, and who it doesn't

If your goal is to publish content as soon as possible and you don't care about the stack or deep customization, WordPress or Ghost are the right answer. There's no need to reinvent the wheel when the existing wheel works for your case.

But if you're a developer, if you want a space that works exactly the way you need it to, if you value full ownership of your content and your infrastructure, and if you see it as an investment in learning as much as a blog, then building from scratch is worth it.

In the next articles in this series, we're going into the details. The technical stack, the custom editor, the security and performance decisions, and the features we realized we needed only after using it for weeks. If you want to go deeper, in the infrastructure with Dokploy we cover it in detail.

"The best tool isn't the most popular one or the newest one. It's the one that fits the way you work."

Another entry in the Building this blog series. The next post is Next.js, SQLite, and Docker, the technical stack.