Since this is my first post, I figured it would be fitting to talk about the platform powering this very blog. Given that this blog is all about software, coding, and technology, I’ll share what tech stack I’m using, why I chose it, and the process behind it.
Static vs. Dynamic Blog: What’s the Difference?
The first big decision I had to make was whether to use a static or dynamic platform for my blog. Let’s break down the differences between the two.
Static blog
As the name suggests, a static blog is made up of static files. It’s much simpler than a dynamic blog since it doesn’t require a database or a complex backend.
Essentially, you write your posts in markdown (.md) or another format, and the static site generator transforms them into HTML, JavaScript, and CSS, which are then served directly by the web server. No need for server-side logic once the files are generated—what you see is what you get.
While static sites tend to be faster because they don’t have to query a database for every page request, they are also somewhat limited in functionality. However, for a straightforward tech blog like mine, speed and simplicity are more important than having a full-featured content management system.
Dynamic blog
Dynamic blogs—like WordPress—are much more user-friendly if you don’t want to touch code. They offer rich functionality out of the box, such as built-in themes, plugins, and content management features. The downside? They rely on a database and a more powerful backend to generate pages on the fly.
For instance, I run a travel blog once using WordPress. My wife and I both contributed to it, and the platform’s built-in tools make it easy for us to upload and organize photos, write posts, and manage the site together. But it does come with some performance issues, especially as traffic grows. Even with caching, I’ve received warnings from my hosting provider (Hostgator shared hosting) about high resource usage.
While WordPress works well for a media-rich, collaborative site like Pieces of the World, it’s not necessary for this simpler blog.
Why I chose a static blog for this blog
Having experienced performance issues with dynamic platforms in the past, I decided to go with a static blog for this project. I don’t need all the extra bells and whistles a dynamic platform offers—I just want something clean, fast, and easy to manage.
The downside of a static blog is that it requires a bit more technical know-how, but that’s not a problem for me. And on the plus side, I don’t have to worry about server load or performance as traffic increases.
This is my first post, so I’m still in the early stages of testing this setup. Whether it will prove to be the best choice over time remains to be seen.
Picking a static site generator
I had never used a static site generator before, so I did some research and came across three main contenders: Jekyll, Hugo, and Hexo. There are plenty of others, but these seemed to be the most popular.
I briefly looked at Jekyll, but Hugo stood out to me for a couple of reasons. First, it’s known for being incredibly fast. Second, it’s written in Go—a language I’ve been curious about. The setup was also super easy: a quick install via Homebrew, and I was up and running in no time. It felt right for what I needed, so I decided to go with Hugo.
Hosting the blog
Who doesn’t love free? For hosting, I looked for a free tier solution and found Netlify. Netlify offers a free tier that’s more than enough for a simple blog, and you only start paying once you hit certain usage limits.
To further optimize performance and keep my Netlify usage within free-tier limits, I added Cloudflare as a CDN (Content Delivery Network). This helps cache the site’s static files and speeds up delivery to visitors.
Conclusion
In the end, I decided to build this blog as a static site using Hugo. It’s too early to say definitively whether this was the best decision, but so far, it feels like the right fit for my needs. Like most things in tech, this is an experiment, and I’ll continue to evolve and refine the setup over time.
Photo by Sean Stratton