How I Spent One Week with Zola

I've been putting off rebuilding my blog for months. I knew I wanted to move away from my current setup, but every static site generator I looked at felt like it required too much overhead. Then I came across Zola, and something about the "single binary, zero dependencies" pitch made me curious enough to give it a real shot.

I gave myself one week. Seven days to evaluate Zola, rebuild my site, and decide if this was the tool I'd been looking for. Here's what actually happened.

Day 1: Setup and First Impressions

The installation was almost anticlimactic. Download a binary, add it to my PATH, run zola init. No virtual environment, no npm install waiting for the progress bar, no dependency resolution. Just... done.

I spent the rest of day one reading through the documentation and setting up the basic structure. The docs are well-organized and surprisingly concise. Within a few hours, I had a basic site running with zola serve, and the live reload was noticeably fast. Not "fast enough" fast—actually fast.

The Tera templating syntax felt immediately familiar. If you've used Jinja2 (and I have), you're basically already trained. I threw together a simple base template and a post layout, and I was rendering Markdown by evening.

Day 1 verdict: This is refreshingly simple. Cautiously optimistic.

Day 2: Content Migration and Structure

I spent day two migrating my existing blog posts and figuring out Zola's content model. This is where the opinionated structure became apparent.

Zola wants you to organize content into sections. Each section is a directory with an _index.md file. Pages are individual markdown files. It's more structured than just dumping markdown files wherever, but once I understood the pattern, it made sense.

The front matter format was slightly different from what I was using before, so I wrote a quick script to convert my posts. Nothing complicated—mostly adjusting date formats and metadata fields.

What surprised me was how fast Zola rebuilt the site even as I was adding more content. I'm used to SSGs slowing down as content grows. Zola just... didn't.

Day 2 verdict: The opinionated structure takes some adjustment but pays off in clarity.

Day 3: Multilingual Support

I needed my site to work in both English and Spanish. This is where I expected pain, because multilingual support is usually either an afterthought or a complex configuration nightmare.

Zola's multilingual support is shockingly straightforward. You add default_language to your config, define your languages, and create content with language codes in the filenames (like about.es.md). That's it. Zola handles the routing and switching.

I spent maybe two hours setting this up, including creating translated versions of my templates. The language switching just worked. No plugins, no complex routing rules, no confusion.

Day 3 verdict: This is how multilingual support should work everywhere.

Day 4: Building the Features I Actually Want

Day four was about building the features I actually needed: a featured posts section, proper pagination, tag pages, and RSS feeds.

RSS was already built-in. Just enable it in the config. Done.

Pagination is built-in. Add a few lines to your template. Done.

Taxonomies (tags, categories) are first-class concepts. Configure them once, use them everywhere.

The featured posts section required a bit more thought. I added a featured field to my post front matter, then filtered posts in my template:

{% set featured = section.pages | filter(attribute="extra.featured", value=true) %}

Clean, readable, works perfectly. By the end of day four, my site had all the features I wanted, and I hadn't written any plugins or external scripts.

Day 4 verdict: Built-in features cover 90% of what you actually need.

Day 5: Styling with Sass

I don't love writing CSS, but I do like Sass for organization and variables. Zola compiles Sass out of the box.

I created a sass directory, wrote my styles with nesting and variables, and Zola just handled it. No webpack configuration, no additional dependencies, no build scripts. It compiled on save and the changes appeared immediately.

This is where the "batteries included" philosophy really clicked. Every time I expected to need an extra tool or plugin, Zola already had it built-in.

Day 5 verdict: The more I use Zola, the less I have to configure.

Day six was cleanup: improving templates, adding proper metadata, testing the build on different content, and making sure everything worked correctly.

I experimented with Zola's shortcodes for embedding content in Markdown. They're straightforward—define a template, call it from markdown. I built a couple for image galleries and code examples.

I also tested the production build. The output is clean, minimal, and fast. Zola doesn't add unnecessary JavaScript or bloat. What you build is what you get.

Day 6 verdict: The polish is in the details Zola got right.

Day 7: Deployment and Reflection

The final day was about deployment. I pushed to GitHub, set up a simple GitHub Action that downloads Zola, builds the site, and deploys to GitHub Pages. The entire CI script is about 15 lines.

No installing Node.js in CI, no pip installing dependencies, no caching layers to speed up repeated builds. Download one binary, run one command, deploy.

As I looked at what I'd built in a week, I realized something: I'd spent most of my time building my site, not configuring my build tool. I wasn't debugging plugin conflicts or wrestling with complicated documentation. I was writing templates, styling pages, and migrating content.

Day 7 verdict: This is what I've been looking for.

What I Learned About Zola

The speed is real. It's not marketing. Rebuilds are genuinely fast enough that the feedback loop feels instant. This matters more than you'd think—it keeps you in flow instead of waiting.

Batteries included works. I'm used to static site generators being minimal cores that you extend with plugins. Zola's approach of including everything is different, but it's efficient. I never had to evaluate plugins or worry about compatibility.

Opinionated structure helps. At first, Zola's structured content model felt restrictive. By day three, I appreciated it. The constraints make things predictable, and predictable means less time deciding how to organize things.

Tera is excellent. The templating is powerful enough for anything I needed but simple enough to read six months from now. The Jinja2 inspiration was the right call.

Zero dependencies isn't just a feature—it's a philosophy. Not managing Python versions, npm packages, or virtual environments removed an entire category of problems. My project is my content and my templates. That's it.

What I Missed (Briefly)

The plugin ecosystem. When I wanted something custom, I had to build it in templates rather than reaching for a plugin. This was actually fine—Tera is capable enough—but there were moments where I wished for a Python script or npm package.

The theme ecosystem is smaller. I built my own design, which I wanted to do anyway, but if you're hoping to grab a polished theme and go, options are limited.

The Verdict

Seven days in, I'm keeping Zola.

This isn't because Zola does things other static site generators can't—it's because Zola does fewer things but does them with less friction. The simplicity isn't simplistic; it's intentional.

I came in skeptical that a tool could be both powerful and simple. Zola proved me wrong by being opinionated about the right things and flexible about everything else.

My blog is live, builds are fast, development is pleasant, and I have zero dependencies to maintain. If that sounds appealing, give Zola a week. You might be surprised how much you can build when the tool gets out of your way.

Resources That Helped

The official Zola documentation (start here)
The Tera template documentation (for advanced templating)
Zola's GitHub discussions (helpful community)
Example sites in Zola's showcase (seeing real implementations helps)

Would I recommend Zola? If you want simplicity, speed, and don't need extensive plugin ecosystems, absolutely. If you need complex Python integrations or want thousands of themes to choose from, look elsewhere.

For me, Zola hit the sweet spot: powerful enough for what I need, simple enough to stay out of my way. One week was enough to be convinced.