If you’ve ever tried building a website, you’ve probably encountered one of two problems:

  1. Off-the-shelf website builders like WordPress, Squarespace, or Ghost feel bloated and require frequent maintenance or jostling.
  2. Building a website from scratch is a time-consuming, never-ending project.

I’ve been through both of these struggles. I wanted a website that made publishing effortless—not one that forced me to tweak settings, troubleshoot plugins, or constantly update my setup just to keep things running.

The goal was simple: a website that lets me focus on writing and sharing ideas, not maintaining a website for the sake of maintaining a website.

Here’s how I built that system, why I ditched traditional solutions, and how you can do the same with minimal hassle.

The problem with existing website solutions

Most website platforms promise simplicity but often end up becoming a headache.

  • WordPress: Requires constant updates, security patches, and plugin management.
  • Squarespace: Easier to use but still forces you into a rigid, closed ecosystem.
  • Webflow: WYSIWYG editor that heavily encourages HTML, CSS, and Javascript knowledge.
  • Ghost: The best of the bunch, but still comes with limitations and costs (like $30+/month for hosting and paid themes).

At first, I tried to work within these platforms. Many, many times. But I quickly realized that most of my time was spent managing the website rather than creating content. I wanted a website that worked like a garden—a space where I could grow and share ideas, not spend all my time maintaining (or fixing) the soil.

Understanding the difference between static and dynamic websites

To understand why these platforms were problematic, I first needed to reflect on how websites function.

  • Dynamic websites: These rely on databases and external queries. Every time a visitor loads a page, the server has to pull in data, process it, and then present it. This means more complexity, slower load times, and potential failure points.
  • Static websites: These are simple, pre-built files. When a visitor loads a page, they just download the content without any extra processing. This means faster load times, fewer things that can break, and minimal upkeep.

Most mainstream website builders focus on dynamic site generation, which is overkill for a simple personal website. I realized I didn’t need all that complexity—I just wanted a reliable, fast, and easy-to-maintain publishing system.

In short, I wanted a static site.

Off-the-shelf vs. custom-built

At this point, I had two options:

  1. Stick with a managed platform (WordPress, Ghost, etc.) and deal with the inevitable bloat.

  2. Build a custom website from scratch using HTML, CSS, and JavaScript—but at the cost of time and ongoing maintenance.

I briefly considered the second option, but it felt like reinventing the wheel just for the sake of proving I could do it.

Instead, I needed something in between—a system that was simple, automated, and allowed me to focus on content instead of code.

The Solution: Build a simple, automated publishing workflow

After some research, I found Hugo, a static site generator written in Go (aka Golang).

Here’s why I chose Hugo:

  • No database or backend required. It generates static pages that load instantly (a huge boon to SEO and general user experience)
  • Minimal maintenance. Once built, the site doesn’t need updates or security patches beyond basic infrastructure checks.
  • Templates for everything. I could design a layout once, and every page would automatically follow that format.

I had built a Hugo site once before but made the mistake of trying to build a custom theme from scratch.

… that turned into an unnecessary project of its own. See my previous point about gardening and spending all my time fixing stuff.

This time, I decided to keep it simple—I picked an existing theme and made minimal tweaks.

Connecting Hugo with a content writing tool (Obsidian)

Since Hugo is great for managing static content, the next question was: Where would I write my content?

Enter Obsidian, a notetaking tool that:

  • Uses Markdown, a simple text format that isn’t tied to any specific tool.
  • Stores files locally, giving me more control over my content and where it “lives”.
  • Minimizes formatting distractions, letting me focus purely on creating.

The beauty of this setup is that Obsidian lets me write in the simplest way possible while Hugo handles the website structure.

Automating the publishing workflow

The final step was making the connection between Obsidian → Hugo → Live Website as seamless as possible.

So I wrote a small script that does the following:

  1. Pulls Markdown files from my Obsidian folder.
  2. Converts them into Hugo-compatible blog posts.
  3. Updates the website with a single command.

The result? I can publish an article within 30 seconds of finishing my edits—without ever opening my website’s backend or dealing with a CMS.

Neither WordPress, nor Ghost, nor anything in-between allows me that level of simplicity when it comes time to publish.

Aside:

This whole process was inspired heavily by this NetworkChuck YouTube video where he builds a similar pipeline. I chose not to directly copy his scripts because I knew I wanted an extensible workflow, but if you’re looking for plug-and-play instructions, his tutorial is a gold mine.

The power of Hugo’s static approach

With Hugo, every post follows a consistent template.

If I ever want to change the design of my site—whether it’s adding a sidebar, changing fonts, or adjusting layouts—I only need to update one file. The next time I build the site, every post automatically adopts the new format.

This means better performance and simplicity, leading to faster loadtimes (because no database queries) as well as cost and control advantages (I save on CMS subscriptions and reduce dependency on third-party platforms).

The stoke factor keeps going up.

The big win: Focus on content, not maintenance

In the past, I got caught up in trying to build the perfect website. But that took time away from actually publishing content.

How much time, you ask?

Enough that—by the time I’d built the website and fixed whatever issue-du-jour popped up—I was exhausted and out of time or energy to create.

This time, I set a simple rule: Good is good enough.

If the site functions well and lets me publish effortlessly, that’s all I need.

The real goal is sharing, not maintaining

At the end of the day, building a website shouldn’t feel like a full-time job. The whole point of having a personal site is to share ideas, showcase work, and connect with others—not to spend hours managing plugins, troubleshooting updates, or wrestling with complex platforms.

By choosing Hugo for its simplicity, Obsidian for its ease of writing, and automation to bridge the two, I’ve built a system that lets me focus entirely on content creation. There’s no friction, no unnecessary maintenance, and no distractions pulling me away from the actual work.

If you’re struggling with website complexity, consider a setup that prioritizes ease of use and long-term sustainability.

Here’s the big things I’ve learned (so far) from this build:

  • Most website builders overcomplicate publishing. If my platform makes content creation harder, it’s working against me.

  • Static sites (like Hugo) are a game-changer. They eliminate the need for ongoing maintenance, speed up load times, and keep me in full control of my content.

  • Automation removes friction. The easier it is to publish, the more likely I am to stay consistent.

  • Good is good enough. A website doesn’t have to be perfect—it just has to work well enough that I don’t have to think about it while creating & posting.

This project reminded me that the best system is the one that gets out of my way. With this setup, I can focus on writing, sharing, and iterating on ideas—which, in the end, is what really matters.

If you’re looking for a simpler way to publish online, I highly recommend experimenting with Hugo and Obsidian.

You might find that less really is more.