From Bare Metal to Bare Minimum: My journey using Netlify and Eleventy

Sometimes, we overthink things. I certainly do.

This is the story of how I went from a self-managed, over-engineered site factory — complete with Ansible playbooks and managed databases — to building and deploying three static websites in one evening. I replaced my portfolio, my iOS app landing page, and my badminton club’s website with something far simpler… and way more sustainable.

And yes, AI helped.

TL;DR; I used to run a full-blown site factory with Symfony, EasyAdmin, Ansible, and a custom hosting stack for my personal projects. It was powerful… but also way too much. One evening, I built and deployed three static websites with Claude + Eleventy + Netlify, and haven’t looked back since. Here’s how I killed my infrastructure and found peace (and free SSL).

Chapter 1: Laying the Groundwork

I don’t know about you, but I’ve always needed a concrete example to really learn something. A practical use case that gives me the drive to explore a new tech or dive into a specific topic.

I’ve been passionate about TV shows for years, and when I was just starting out in web development, that was the perfect excuse. My very first HTML site? A list of my VHS and DVD collection. Then came raw PHP when I wanted things to be more dynamic. Later, I discovered Joomla because I needed a CMS to handle the growing mess.

Eventually, I moved on to building my own online website. It became a kind of ongoing experiment. I must have rebuilt that site ten times in the last fifteen years. New tech (Ruby, PHP, React, …), new framework (Sonata, Angular, EasyAdmin, …), new infra (Puppet, Ansible, …) new reason to start over. And every time, I spent evenings and weekends making sure the site was solid, maintainable, and up to my quality standards.

Each rebuild came with its own hosting solution, because why not. The last version was the most ambitious: I set up a bare metal server, managed the full infrastructure with Ansible, full CI and quality tools, and built a full-blown site factory using Symfony and EasyAdmin for the backend, React for the frontend. It powered my portfolio and a couple of simple satellite sites.

Sounds clean, right? It was. But it took forever. Between learning Ansible, tweaking recipes, managing SSL certs, and automating deployment by domain, I spent an absurd amount of time on it. It worked great, and I was kinda proud of it.

But then, I wanted to add my badminton club’s site to the mix. And that’s when I realized this whole site-factory thing didn’t fit the need. At all.

Time passed, several years where I didn’t touch it at all, waiting for the next big idea…

Then, during some light techwatch, I discovered a new solution: Netlify. It lets you deploy static sites easily, for free. I thought, maybe it’s time to scrap the factory and spin up a couple of static sites that just do their job.

Side note :
One nice perk of Netlify: it’s completely free even for commercial projects — which isn’t true for every PaaS. Just be mindful that traffic can become costly if your site suddenly blows up, as bandwidth is capped. In short: success comes with a bill. The upside is that it forces you to optimise your assets — good for your wallet, and for the planet. Note that Cloudflare offers unlimited bandwidth for static sites, which might be another option worth exploring.
Thanks Benjamin !

So I jumped in. But this time, I called for backup.

“Claude, you around?”

Claude usage limit reached. Come back in 2h.

Okay… “Honey, I’ll make dinner tonight.”

Chapter 2: Hitting Start

Once Claude came back online, I pitched him the project.

As usual, I was right (obviously), but he brought up an important consideration:

Why not use a static site generator?

At ekino, we use Hugo, mostly because some folks are into Go. But I had just finished working on an iOS app, so I was more in a Node.js state of mind. Claude suggested Eleventy (11ty). Looked simple enough. Plus, its templating engine, Nunjucks, reminded me of Twig. That was enough to get me started.

I began with the biggest piece: my badminton club’s site.

I handed Claude six Twig templates, a base template, a folder full of assets, and said:

Do your thing.

Claude converted the templates to Nunjucks, created JSON data files to replace my repository calls, and gave me these instructions:

Run : `npm install` and `npm run dev`
Then open your Browser : "http://localhost:8080"

I followed the steps, and 💥.

The club site showed up with the correct templates, assets, compiled CSS and JS. 70% of the work was done.

I tweaked some data files, updated content, and just like that — the site was fully ready locally.

Riding that high, I created a Netlify account, linked my GitLab repo, and 💥 again: site deployed. I fixed a typo, committed, pushed… and less than 20 seconds later, the site was live with the update.

This was exactly what I needed: simplicity.

Sure, I lost some of the admin features I had with EasyAdmin. But for a badminton club site? I can live without a backend.

And best of all: everything was taken care of.

• SSL certificates
• Continuous deployment
• Infrastructure
• CI
• Softwares versions
• Database

I didn’t have to manage a single thing. Push, done.

Chapter 3: Getting in the Flow

Of course, I didn’t stop there.

Next up: my iOS app website. I reused the config from the badminton site. New repo, new goal: a landing page for Smashduck, my iOS app. Back to Claude:

I need a landing page for my app. Here’s the README. Figure out what it does, create a simple but clean visual identity, generate a privacy page, and write a proper README for the repo.

While I took the dog out for a quick walk, Claude did his magic. Came back and… 💥. Everything was there.

The landing page was solid, with the right messaging and structure. It just worked. Bought a domain, hooked it up to Netlify, and boom: site live.

And then I thought, why stop now? It’s only 11pm, still got time right?

Might as well do the same for my personal site. That way, I can kill off the VPS, ditch the managed DB, drop the AWS backups, and stop syncing with Backblaze. Simplify everything.

Same drill. I told Claude what I wanted to keep, what he could rewrite, and how to structure the rest. Less than an hour later, I had a shiny, clean new version of my personal site.

No infra. No headache. No regrets.

Bonus Chapter: Show me the code

Before giving Claude full control of the project, I like to set up a few starting files to give structure to the project. Here’s an example file tree:

website/
├── src/
│   ├── _layouts/          # Nunjucks templates
│   │   └── base.njk       # Base layout
│   ├── assets/
│   │   ├── css/           # Stylesheets
│   │   ├── js/            # JavaScript files
│   │   └── images/        # Images and screenshots
│   ├── index.njk          # Homepage
│   └── page1.njk          # Page1
├── .eleventy.js           # Eleventy configuration
└── package.json           # Dependencies and scripts

//.eleventy.js

module.exports = function(eleventyConfig) {
  eleventyConfig.addPassthroughCopy("src/assets");

  return {
    dir: {
      input: "src",
      output: "_site",
      includes: "_layouts",
      data: "_data"
    },
    templateFormats: ["njk", "md", "html", "liquid"],
    htmlTemplateEngine: "njk",
    markdownTemplateEngine: "njk"
  };
};

<!-- base.njk -->
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="utf-8" />
    <title>{{ title }}</title>
    <meta content="width=device-width, initial-scale=1.0" name="viewport" />
    <meta property="og:image" content="/images/apple-touch-icon.png" />
    <link rel="icon" type="image/x-icon" href="/images/favicon.ico" />
    <link rel="stylesheet" href="/assets/css/style.css" />
  </head>
  <body>
    <main>
      {{ content | safe }}
    </main>
    <script type="text/javascript" src="/assets/js/script.js"></script>
  </body>
</html>

<!-- index.njk -->
---
layout: base.njk
title: "My awesome title"
---

<h1>Hello world</h1>

// package.json
{
  "name": "my-website",
  "version": "1.0.0",
  "scripts": {
    "build": "eleventy",
    "start": "eleventy --serve",
    "dev": "eleventy --serve --watch",
    "clean": "rm -rf _site"
  },
  "devDependencies": {
    "@11ty/eleventy": "^2.0.1",
    "concurrently": "^8.2.2",
    "nodemon": "^3.0.1"
  },
  "dependencies": {}
}

Once this base is in place, open Claude and brief him on the project:

• What you want the site to do
• Any design goals or tone (don’t hesitate to give him only one color if you have nothing else)
• Ask him to write a README for setup and onboarding
• And of course, build his own CLAUDE.md to carry the context forward

Meanwhile, configure Netlify to hook it to your repo, this way each time you push to the main branch, it will automatically fetch the changes, build the website and deploy it. So at the end: commit, push, and voilà.

You now have everything in place to build your static site the smart way.

Of course, you can skip my starter files and ask Claude to generate everything from scratch — this example is just here to help you visualize the structure before giving him the reins.

The Moral of the Story

Stay curious. Keep exploring. And never forget to use the right tool for the right job, it helps 🙂

Even if I move on to something else in six months (or six years), I’ll have learned something new.

---

From Bare Metal to Bare Minimum was originally published in ekino-france on Medium, where people are continuing the conversation by highlighting and responding to this story.