Home / Blog / Getting Started with #11ty and #BuildAwesome

Here is my lecture on building a website with Build Awesome (the static site generator formerly known as 11ty).


In L. Frank Baum's The Wonderful Wizard of Oz (1900), the great and terrible Oz turns out to be a humbug, an ordinary man working levers behind a screen. Much of modern web development performs the same trick with bigger machinery. I will argue that a website is, at bottom, a folder of files, and that 11ty (now also called Build Awesome) is the best place to start building one, by walking you through a small portfolio site built on three ideas: a src folder, a _data folder, and one layout.

By the end you will have a working site at localhost:8080, styled with Blades CSS, and four ways to put it online (GitHub Pages, Netlify, xmit, and Bunny). The sample site below builds and serves cleanly on Node 22 with Eleventy 3.1.8 (November 2026). The hosting steps follow each host's current documentation.

A Note on Names: 11ty, and Build Awesome #

Eleventy, 11ty, and Build Awesome name one project. Eleventy joined Font Awesome in September 2024, and in March 2026 its creator, Zach Leatherman, announced the rename to Build Awesome (hence the hashtag). The announcement promises that version 4 ships under the new name and that existing plugins and build commands keep working.

For a beginner the practical point is simple. As of November 2026 the stable release is Eleventy 3.1.8, installed as @11ty/eleventy. Build Awesome v4 is still an alpha (4.0.0-alpha.10), installed as @awesome.me/buildawesome (v4 docs). This guide uses the stable release, and a later section shows how to try the alpha. When v4 arrives the name on the package changes, and the project promises your folder of files will not have to.

An Easy Setup #

You need Node.js 18 or newer (an even-numbered release such as 22 or 24 is the safer choice) and a terminal. Run node -v to see what you have. Then type five lines:

mkdir my-portfolio
cd my-portfolio
npm init -y
npm pkg set type="module"
npm install @11ty/eleventy

Those lines make a folder, create a package.json (the project's ID card), tell Node to use modern import syntax, and install Eleventy.

Mapping npm run dev to localhost:8080 #

A fresh Eleventy project has no npm run dev. Type it now and npm answers Missing script: "dev". Eleventy's own command for a local preview is npx @11ty/eleventy --serve, and npm run dev is a nickname you have to create yourself.

Nicknames live in the scripts block of package.json. Open that file and make the block read:

"scripts": {
  "dev": "eleventy --serve --port=8080",
  "build": "eleventy"
}

Or let npm write the same block for you:

npm pkg set scripts.dev="eleventy --serve --port=8080" scripts.build="eleventy"

Here is the chain from the command to the address. npm run dev looks up dev in scripts and runs eleventy --serve --port=8080. The --serve flag builds the site, starts Eleventy's built-in web server, and rebuilds every time you save a file.

The --port=8080 flag names the door, so the site answers at http://localhost:8080 (localhost means "this computer"). Eleventy already defaults to port 8080, so the flag only makes the mapping visible. Change the number and the address changes with it (--port=3000 gives you localhost:3000).

npm run build runs plain eleventy, which writes the finished site once and exits (every host below runs this command). Last, create a .gitignore file so Git skips the two folders you never commit:

node_modules
_site

Organizing with a src Folder #

Out of the box, Eleventy treats the project root as its input, so your pages end up sitting beside package.json and node_modules. A src folder fixes that clutter. What you write lives in src, what Eleventy builds lands in _site, and the configuration stays at the root. Here is the whole project you are about to build:

my-portfolio/
├── eleventy.config.js
├── package.json
├── .gitignore
└── src/
    ├── _data/
    │   ├── metadata.yml
    │   └── projects.json
    ├── _includes/
    │   └── layouts/
    │       └── base.njk
    ├── index.njk
    └── about.md

To tell Eleventy about src, create eleventy.config.js at the root:

export const config = {
  dir: {
    input: "src",
    output: "_site",
  },
  markdownTemplateEngine: "njk",
  htmlTemplateEngine: "njk",
};

The dir block names the input and output folders. Eleventy looks for _data and _includes inside the input folder, which is why both live under src. The last two lines set Nunjucks (the .njk files, with their {{ curly }} tags) as the one templating language for Markdown and HTML alike, so you only have one syntax to learn.

The _data Folder: metadata.json or metadata.yml #

Every file in src/_data becomes a variable you can use on every page, named after the file. A file called metadata.json becomes metadata, so {{ metadata.title }} prints your site title anywhere. You write your name once, in one place, and the whole site reads from it.

Option 1: metadata.json #

JSON works with no extra setup. Create src/_data/metadata.json:

{
  "title": "Dorothy Gale",
  "description": "Writer, traveler, and reluctant witch-slayer from Kansas.",
  "url": "https://example.com",
  "author": {
    "name": "Dorothy Gale",
    "email": "[email protected]"
  },
  "nav": [
    { "label": "Home", "url": "/" },
    { "label": "About", "url": "/about/" }
  ]
}

Option 2: metadata.yml #

YAML holds the same data with less punctuation (no braces, no quotation marks, and you can leave yourself comments). Create src/_data/metadata.yml:

title: Dorothy Gale
description: Writer, traveler, and reluctant witch-slayer from Kansas.
url: https://example.com
author:
  name: Dorothy Gale
  email: [email protected]
nav:
  - label: Home
    url: /
  - label: About
    url: /about/

Eleventy does not read YAML data files until you teach it to. Install a YAML parser with npm install js-yaml, then add a function above the config export in eleventy.config.js:

import { load } from "js-yaml";

export default function (eleventyConfig) {
  eleventyConfig.addDataExtension("yml,yaml", (contents) => load(contents));
}

One warning will save you an error. The official docs show import yaml from "js-yaml", and that line fails with js-yaml 5 (the version npm installs today), which has no default export. The { load } form above works.

Pick one format and stay with it. If metadata.json and metadata.yml both exist, the JSON file wins and the YAML file is ignored. The sample site uses metadata.yml for site settings and a plain JSON file for the project list, so you can see both at work.

A third option: JavaScript data files #

A data file can also be JavaScript, which helps when a value has to be computed. A file at src/_data/build.js gives every page {{ build.year }} for the footer:

export default {
  year: new Date().getFullYear(),
};

Getting Started with Blades #

Blades CSS is a fork of Pico CSS, a small stylesheet that styles plain, semantic HTML. You write <nav>, <main>, and <article>, and Blades makes them look finished, with light and dark modes included. You learn two class names in this guide (container and grid) and no build tooling.

The fastest way in is one line in your page's <head>, straight from the Blades quick start:

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@anyblades/blades@3/css/blades.min.css">

I prefer to install Blades and serve the file from my own site, so the page depends on no one else's server:

npm install @anyblades/blades

Then ask Eleventy to copy the stylesheet into the built site. With the YAML line from the last section, your finished eleventy.config.js reads:

import { load } from "js-yaml";
import { HtmlBasePlugin } from "@11ty/eleventy";

export default function (eleventyConfig) {
  // Teach Eleventy to read .yml and .yaml files in _data
  eleventyConfig.addDataExtension("yml,yaml", (contents) => load(contents));

  // Copy Blades CSS out of node_modules and into the built site
  eleventyConfig.addPassthroughCopy({
    "node_modules/@anyblades/blades/css/blades.min.css": "css/blades.min.css",
  });

  // Rewrite URLs when the site lives in a subfolder (GitHub Pages project sites)
  eleventyConfig.addPlugin(HtmlBasePlugin);
}

export const config = {
  dir: {
    input: "src",
    output: "_site",
  },
  markdownTemplateEngine: "njk",
  htmlTemplateEngine: "njk",
};

The HtmlBasePlugin line ships with Eleventy and costs nothing now. It pays off in the hosting section, when GitHub Pages serves your site from a subfolder.

Blades also pairs with a larger kit. Build Awesome One bundles an Eleventy plugin (@buildawesome.one/plugin), a config, and a starter built on Blades. Build this small site by hand first, then go look at the kit, and you will recognize every part of it.

A Simple Sample Portfolio #

The portfolio needs four more files: a list of projects, one layout, a home page, and an about page. Our client is Dorothy Gale, of Kansas. Swap in your own name and work as you go.

1. The project list #

Create src/_data/projects.json. Because the file sits in _data, every page can loop over projects:

[
  {
    "title": "Notes from the Yellow Brick Road",
    "year": 2026,
    "summary": "A travel journal in twelve posts, with maps.",
    "url": "https://example.com/yellow-brick-road/"
  },
  {
    "title": "An Emerald City Field Guide",
    "year": 2025,
    "summary": "A photo essay on green glass and civic spectacle.",
    "url": "https://example.com/emerald-city/"
  },
  {
    "title": "There's No Place Like localhost",
    "year": 2024,
    "summary": "A talk on building small, personal websites.",
    "url": "https://example.com/localhost/"
  }
]

2. The layout #

A layout is the frame every page shares (the head, the navigation, the footer). Create src/_includes/layouts/base.njk:

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="color-scheme" content="light dark">
    <title>{% if title %}{{ title }} | {% endif %}{{ metadata.title }}</title>
    <meta name="description" content="{{ description or metadata.description }}">
    <link rel="stylesheet" href="/css/blades.min.css">
  </head>
  <body>
    <header class="container">
      <nav>
        <ul>
          <li><strong>{{ metadata.title }}</strong></li>
        </ul>
        <ul>
          {%- for item in metadata.nav %}
          <li><a href="{{ item.url }}">{{ item.label }}</a></li>
          {%- endfor %}
        </ul>
      </nav>
    </header>

    <main class="container">
      {{ content | safe }}
    </main>

    <footer class="container">
      <small>&copy; {{ metadata.author.name }}. Built with 11ty and Blades.</small>
    </footer>
  </body>
</html>

Three things happen in that file. The metadata values come from your data file, the for loop builds the navigation from the nav list, and {{ content | safe }} marks the spot where each page's own content drops in.

3. The home page #

Create src/index.njk. The lines between the --- marks are front matter (settings for this one page), and here they choose the layout:

---
layout: layouts/base.njk
---
<h1>{{ metadata.title }}</h1>
<p>{{ metadata.description }}</p>

<h2>Projects</h2>
<div class="grid">
  {%- for project in projects %}
  <article>
    <header><strong>{{ project.title }}</strong> ({{ project.year }})</header>
    <p>{{ project.summary }}</p>
    <footer><a href="{{ project.url }}">View project</a></footer>
  </article>
  {%- endfor %}
</div>

Blades turns each <article> into a card and the grid class sets the cards side by side on a wide screen. To add a fourth project, add one entry to projects.json and save. You never touch the HTML.

4. The about page #

Pages can be Markdown too. Create src/about.md:

---
layout: layouts/base.njk
title: About
---
# About

I am {{ metadata.author.name }}. I write about roads, cities, and the long way home.

You can reach me at [{{ metadata.author.email }}](mailto:{{ metadata.author.email }}).

Eleventy turns about.md into /about/ on your site, and the title: About line feeds the browser tab through the layout.

npm install and npm run dev #

If you followed along, your packages are already installed. If you cloned the project from GitHub (or came back to it on a new computer), run npm install first, which reads package.json and downloads everything it lists. Then start the site:

npm install
npm run dev

The terminal reports what Eleventy built and where to find it:

[11ty] Writing ./_site/index.html from ./src/index.njk
[11ty] Writing ./_site/about/index.html from ./src/about.md (njk)
[11ty] Copied 1 Wrote 2 files in 0.08 seconds (v3.1.8)
[11ty] Watching…
[11ty] Server at http://localhost:8080/

Open http://localhost:8080 in your browser and you will see Dorothy's portfolio. Change the title in metadata.yml, save, and the page reloads on its own. Press Ctrl+C in the terminal to stop the server.

When you are ready to publish, npm run build writes the finished site into _site (two HTML pages and one stylesheet). That folder is the whole website. There is no database, no server program, and no wizard, only files that any web host can serve.

Growing the Site: Templating and Directory Data Files #

Dorothy now wants a blog. A blog adds two problems the portfolio did not have. Many pages share one design, which is a templating problem, and many pages share the same front matter, which is a data problem. Eleventy answers the first with includes, layout chains, and filters, and the second with directory data files.

Templating: includes, layout chains, and filters #

You have already met the core of Nunjucks: {{ value }} prints something, {% for %} loops, and {% if %} decides. Three more tools carry you a long way.

An include pulls a small file into a larger one. Move the <nav> block out of base.njk into src/_includes/partials/nav.njk, and mark the current page while you are at it:

<nav>
  <ul>
    <li><strong>{{ metadata.title }}</strong></li>
  </ul>
  <ul>
    {%- for item in metadata.nav %}
    <li><a href="{{ item.url }}"{% if item.url == page.url %} aria-current="page"{% endif %}>{{ item.label }}</a></li>
    {%- endfor %}
  </ul>
</nav>

Then replace the <nav> in base.njk with one line, {% include "partials/nav.njk" %}. The page.url variable is one Eleventy hands every template, and aria-current tells screen readers (and Blades) which link is the page you are on. Add { "label": "Posts", "url": "/posts/" } to the nav list in your metadata file so the blog shows up.

A layout chain lets one layout wear another. A post needs a title and a date above its text, but it should keep the same head, nav, and footer as every other page. Create src/_includes/layouts/post.njk:

---
layout: layouts/base.njk
---
<article>
  <header>
    <h1>{{ title }}</h1>
    <time datetime="{{ page.date.toISOString() }}">{{ page.date | readableDate }}</time>
  </header>
  {{ content | safe }}
</article>

The post layout fills in the middle, then hands the whole thing to base.njk, which wraps it in the frame. You never copy the <head> twice.

A filter reshapes a value on its way to the page. The | in {{ content | safe }} was a filter all along. Nunjucks ships with many (upper, default, length, join), Eleventy adds a few (url, slugify), and you can write your own. The readableDate filter above is not built in, so add it inside the function in eleventy.config.js:

  // Turn a date into "October 1, 2026"
  eleventyConfig.addFilter("readableDate", (date) =>
    date.toLocaleDateString("en-US", { dateStyle: "long", timeZone: "UTC" })
  );

The timeZone: "UTC" matters. Eleventy reads date: 2026-10-01 as midnight UTC, and without that option a reader west of Greenwich would see September 30.

Directory data files: front matter for a whole folder #

Every post needs layout: layouts/post.njk and a posts tag. You could type both lines into every file, and you would forget one by the third post. A directory data file sets them once for a whole folder. Here is where the blog lives:

src/
├── posts.njk
├── sitemap.njk
└── posts/
    ├── posts.11tydata.json
    ├── leaving-kansas.md
    └── archive/
        ├── archive.11tydata.json
        ├── old-post.md
        └── the-cyclone.md

The rule for the name is strict: the data file takes the name of its folder, plus .11tydata.json (or .11tydata.js). So src/posts/posts.11tydata.json reads:

{
  "layout": "layouts/post.njk",
  "tags": ["posts"],
  "sitemap": {
    "ignore": false,
    "changefreq": "monthly"
  }
}

Now a post needs only what is unique to it. Here is src/posts/leaving-kansas.md:

---
title: Leaving Kansas
date: 2026-10-01
---
The house came down in the middle of a country of marvelous beauty.

It gets its layout and its tag from the folder, and its title and date from itself. The data also flows down into child folders, so everything in posts/archive/ inherits the same layout and tag.

The tag does more work than a label. Every tag becomes a collection, a list of the pages that carry it, so tags: ["posts"] gives you collections.posts to loop over. Create src/posts.njk for the blog's front page:

---
layout: layouts/base.njk
title: Posts
---
<h1>Posts</h1>
<ul>
  {%- for post in collections.posts | reverse %}
  <li><a href="{{ post.url }}">{{ post.data.title }}</a> ({{ post.date | readableDate }})</li>
  {%- endfor %}
</ul>

Collections sort oldest first, so the reverse filter puts the newest post on top.

The data cascade: who wins #

When the same key turns up in more than one place, Eleventy settles it by the data cascade. From strongest to weakest:

  1. Computed data (eleventyComputed, which you can skip for now)
  2. The page's own front matter
  3. A data file just for that page (the-cyclone.11tydata.json beside the-cyclone.md)
  4. Directory data files, the nearest folder first (archive/ beats posts/)
  5. Front matter in the page's layouts
  6. Global data in _data

Two details trip people up. First, a plain value such as layout or title is simply replaced by the stronger source. Second, lists and objects are merged, not replaced. If posts/ sets tags: ["posts"] and archive/ sets tags: ["archive"], an archived post carries both tags and appears in both collections.

Keeping a folder out of the sitemap, then letting one post back in #

Here the cascade earns its keep. Dorothy wants her old posts online but left out of the sitemap, so search engines spend their attention on new work. One file does it, src/posts/archive/archive.11tydata.json:

{
  "tags": ["archive"],
  "sitemap": {
    "ignore": true
  }
}

Because objects merge, the archive keeps changefreq: "monthly" from its parent and changes only ignore. One archived post, "The Cyclone," is still her most-read piece, so its front matter overrules the folder:

---
title: The Cyclone
date: 2024-02-01
sitemap:
  ignore: false
---

Front matter is stronger than a directory data file, so this one post goes back in while the rest of the archive stays out. If you would rather leave the Markdown alone, a companion file at src/posts/archive/the-cyclone.11tydata.json holding the same sitemap object does the same job.

Nothing reads sitemap.ignore yet. It is a key I made up, and Eleventy passes it along without knowing what it means. Something has to act on it, and that something can be one more template. Create src/sitemap.njk:

---
permalink: /sitemap.xml
eleventyExcludeFromCollections: true
---
<?xml version="1.0" encoding="utf-8"?>
<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
{%- for item in collections.all %}
{%- if not item.data.sitemap.ignore %}
  <url>
    <loc>{{ metadata.url }}{{ item.url }}</loc>
    <lastmod>{{ item.date.toISOString().slice(0, 10) }}</lastmod>
  </url>
{%- endif %}
{%- endfor %}
</urlset>

The permalink line tells Eleventy to write this template to /sitemap.xml instead of a folder of HTML. collections.all holds every page on the site, and the if skips any page whose data says ignore. The eleventyExcludeFromCollections line keeps the sitemap from listing itself. Build the site and the sitemap holds the home page, the about page, the posts page, "Leaving Kansas," and "The Cyclone," but not "Old Post."

If you would rather use a plugin, @quasibit/eleventy-plugin-sitemap reads the same key, sitemap.ignore, along with sitemap.changefreq and sitemap.priority. Whatever builds your sitemap, check which key it reads. A key no one reads does nothing, and does it silently.

When merging is the wrong answer: override: #

Sometimes you want a child folder to replace a list or object instead of adding to it. Put override: in front of the key:

{
  "override:tags": ["archive"]
}

With that line in archive.11tydata.json, archived posts carry only the archive tag. Be careful with it. They also lose posts, so they drop out of collections.posts and off the blog's front page. Merging is usually what you want, and override: is the exception.

Which key does what #

You want to Set this
Give a page or folder a layout layout
Put pages in a collection tags
Replace inherited tags instead of adding override:tags
Keep a page out of your sitemap only sitemap.ignore: true (or whatever key your sitemap reads)
Keep a page out of every collection eleventyExcludeFromCollections: true
Build no HTML file for a page at all permalink: false

Reach for the gentlest key that does the job. eleventyExcludeFromCollections hides a page from the sitemap, but also from the blog list, the feed, and every tag page, which is rarely what you meant.

Trying the Canary: Build Awesome v4 Before It Ships #

Everything above runs on the stable release. If you want to see where the project is headed, you can run the v4 alpha, and you have two doors into it. Both lead to the same code today (version 4.0.0-alpha.10 as of November 2026), and the sample portfolio builds and serves at localhost:8080 through either one.

Door 1: the canary under the old name #

npm install @11ty/eleventy@canary

Nothing else changes. Your scripts, your config, and your src folder stay as they are. canary is a tag (a movable label) that the project points at its newest pre-release, so this door is the gentlest way to test v4.

Door 2: the alpha under the new name #

npm uninstall @11ty/eleventy
npm install @awesome.me/buildawesome@alpha

Keep the @alpha on the end. The v4 docs show the install without a tag, but the package's default tag still points at version 0.0.3, and the alpha is the one you want. Then make three small edits. First, in package.json, the command changes from eleventy to buildawesome:

"scripts": {
  "dev": "buildawesome --serve --port=8080",
  "build": "buildawesome"
}

Second, in eleventy.config.js (the file keeps its name), the plugin import changes its source:

import { HtmlBasePlugin } from "@awesome.me/buildawesome";

Third, in the GitHub Pages workflow below, npx @11ty/eleventy becomes npx buildawesome. Your terminal now signs its lines [buildawesome] where it used to say [11ty].

Before you depend on it #

An alpha can change or break between releases. Use it for a practice site, and keep the stable release on any site you need to work tomorrow. To go back, run npm install @11ty/eleventy@latest (and, if you took Door 2, undo the three edits).

Hosting: Four Ways Home #

Every host below does the same two things: it runs npm run build and it serves the _site folder. They differ in who runs the build and how the files travel. Before any of them, put the project on GitHub and commit package-lock.json (the automated builds need it).

Host How the site gets there What you set up Reach for it when
GitHub Pages A GitHub Actions workflow builds on every push One workflow file, one repository setting Your code already lives on GitHub
Netlify Netlify watches the repository and builds on every push A build command and a publish folder You want the least setup
xmit A command-line tool uploads _site An API key and a DNS record You like deploying with one command
Bunny The Bunny CLI, or a GitHub Action, fills a storage zone A storage zone and a pull zone You want a CDN you configure yourself

I have left prices out because they change. Check each host's pricing page before you commit.

GitHub Pages with GitHub Actions #

In your repository, open Settings, then Pages, and set the source to "GitHub Actions" (Eleventy's deployment docs describe the same step). Then create .github/workflows/deploy.yml:

name: Deploy to GitHub Pages

on:
  push:
    branches: [main]
  workflow_dispatch:

permissions:
  contents: read
  pages: write
  id-token: write

concurrency:
  group: "pages"
  cancel-in-progress: false

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
        with:
          node-version: 22
          cache: npm
      - run: npm ci
      - run: npx @11ty/eleventy --pathprefix=/my-portfolio/
      - uses: actions/upload-pages-artifact@v3
        with:
          path: _site

  deploy:
    needs: build
    runs-on: ubuntu-latest
    environment:
      name: github-pages
      url: ${{ steps.deployment.outputs.page_url }}
    steps:
      - id: deployment
        uses: actions/deploy-pages@v5

The --pathprefix flag matters. A project site lives at yourname.github.io/my-portfolio/, a subfolder, so every link needs that prefix (set it to your repository's name). The HtmlBasePlugin you added earlier rewrites the links for you. If you use a custom domain, or the repository is named yourname.github.io, replace that line with npm run build.

Netlify #

Netlify needs no workflow file. Add a new project in Netlify, import your repository, and Netlify detects Eleventy and suggests the settings (Netlify's Eleventy guide). To keep those settings in the repository, where you can see them, add a netlify.toml at the root:

[build]
  command = "npm run build"
  publish = "_site"

Every push to your main branch now triggers a build and a deploy.

xmit.co #

xmit hosts static sites and deploys from the command line. Create an account, make an API key in the admin page, and then run:

npm install @xmit.co/xmit --save-dev
npx xmit set-key
npm pkg set scripts.deploy="npm run build && xmit example.com _site"
npm run deploy

Replace example.com with your domain, and keep the _site at the end. The tool's pattern is xmit DOMAIN [DIRECTORY], and the xmit guide assumes a dist folder, which is not where Eleventy writes. For DNS, the guide has you point a CNAME record for the domain and for its www twin at your team's address (your team number, then .xmit.co). The same guide notes that free .xmit.dev subdomains exist if you do not own a domain yet.

To deploy on every push instead, store a team key as a repository secret named XMIT_KEY and run npm run deploy in a workflow.

Bunny #

Bunny serves a static site from two parts: a storage zone (where the files sit) and a pull zone (the CDN in front of them). You have two routes. The newer one is the Bunny CLI, which creates both zones and deploys for you (the bunny sites commands are in public preview, so they may change):

npm install -g @bunny.net/cli
bunny login
bunny sites create my-portfolio
bunny sites deploy --build

Run bunny sites ci init afterward and the CLI writes a GitHub Actions workflow for you. It expects your API key in a repository secret named BUNNYNET_API_KEY.

The second route is the one Chris McLeod documents in "Migrating an Eleventy Site to Bunny.net". You create the storage zone and pull zone in the dashboard, save four values as repository secrets, and let a community GitHub Action upload the build. Adapted for this project (McLeod's site builds to dist, ours to _site), the steps after checkout and Node setup read:

      - run: npm ci
      - run: npm run build
      - uses: ayeressian/bunnycdn-storage-[email protected]
        with:
          source: "_site"
          destination: ""
          storageZoneName: "${{ secrets.STORAGE_NAME }}"
          storagePassword: "${{ secrets.STORAGE_PASSWORD }}"
          accessKey: "${{ secrets.ACCESS_KEY }}"
          pullZoneId: "${{ secrets.ZONE_ID }}"
          upload: "true"
          remove: "true"
          purgePullZone: "true"

If your storage zone sits outside the default region, add a storageEndpoint line (McLeod uses the UK endpoint). Two of his lessons are worth borrowing: test on the temporary b-cdn.net address before you attach your real domain, and expect to set redirects and security headers as Edge Rules in the Bunny dashboard, since there is no config file for them.

Conclusion #

Dorothy learns, in the end, that the wizard held no power she lacked. The same holds here. You built a website from a folder of files: a src folder for what you write, a _data folder for what you know, and one layout to frame both. When the site grew a blog, the same ideas stretched to fit: data files for whole folders, layouts that wear other layouts, and a cascade that decides who wins. A feed or a hundred pages will ask you to learn more, but each builds on what you have here.

Call the tool 11ty, Eleventy, or Build Awesome. The curtain is open now, and what stands behind it is a folder you understand.

Sources #

Tags : digital-humanities indieweb smol-web how-to eleventy build-awesome

Webmentions

No webmentions yet.

Previous

Leaving the Corporate Web: A Practical Return to the Independent Web

A step-by-step plan for scholars, students, and curious people who want to move their writing and identity off corporate platforms and onto a web they control, without deleting every account in a dramatic midnight purge.