Static Sites Without the Bloat: Quesby’s Approach to Modern Web Dev

Modern web tooling is powerful—sometimes too powerful for what most projects actually need.

Frameworks today are engineered to handle broad, complex use cases: dynamic apps, interactive dashboards, real-time data, entire design systems running in the browser.

Static sites sit on the opposite end of the spectrum.

They rarely need that level of machinery, yet developers still feel the weight of choices designed for far larger problems.

Quesby takes a different angle: use only what serves a static site well, keep the workflow predictable, and avoid carrying tools that won’t be used.

1. Why Quesby Exists

Most developers have lived this scenario: you start a simple website, open your tooling of choice, and suddenly you’re dealing with bundlers, configs, dependencies, and features that aren’t relevant to your project.

Nothing wrong with those tools—they're built for ambitious apps.

But when you're generating HTML pages, that ecosystem can become unnecessary overhead.

Quesby focuses on the common needs of static sites:

• predictable structure
• clean templates
• good SEO
• image optimization
• no hidden integrations
• no configuration sprawl

It doesn't try to be a universal solution.

It tries to be a good one for a specific class of projects.

2. Design Principles

Three core ideas shape Quesby:

2.1 Use the Right Tool for the Job

Quesby builds on Eleventy because its philosophy fits the nature of static sites: generate HTML from templates, nothing more unless asked.

No runtime attached.

No front-end framework assumptions.

2.2 Keep the Surface Area Small

Tools that don’t add value aren’t included.

No analytics by default.

No external fonts.

No client-side libraries unless you opt in.

The goal isn’t “minimalism for aesthetic reasons”.

It’s “don’t ship or maintain what you don’t use”.

2.3 Make Everything Observable and Replaceable

Quesby avoids black boxes.

Every layer—content, templates, SEO, assets—lives in a place you can inspect and customize.

If you want to extend it, nothing fights you.

3. What Quesby Adds on Top of Eleventy

Quesby doesn’t reinvent the Eleventy workflow.

It refines it for real-world use.

3.1 Centralized SEO

Front matter becomes a single source for:

• meta tags
• OpenGraph
• Twitter Cards
• JSON-LD
• canonical URLs
• language alternates

Instead of juggling separate plugins, Quesby consolidates the logic into a predictable module.

You define SEO once in front matter:

---
title: "Static Sites Without the Bloat"
description: "How Quesby trims modern tooling down to what static sites actually need."
image: "/assets/images/posts/static-sites-without-the-bloat/cover.jpg"
---

Quesby turns that into consistent markup:

<title>Static Sites Without the Bloat | Example Site</title>
<meta name="description" content="How Quesby trims modern tooling down to what static sites actually need.">
<meta property="og:title" content="Static Sites Without the Bloat">
<meta property="og:image" content="https://example.com/assets/images/posts/static-sites-without-the-bloat/cover.jpg">
<!-- ...additional structured data... -->

3.2 Image Handling That Makes Sense

Eleventy Image is powerful but noisy.

Quesby wraps it with defaults that handle:

• WebP/AVIF output
• fallbacks
• modern markup
• lazy-loading
• deterministic filenames

You get the good parts without the friction.

A typical image in a template might look like:

{% image "src/assets/images/posts/static-sites/cover.jpg", "Cover image for the article", "article-cover" %}

Quesby handles responsive sources, formats, and attributes like loading="lazy" for you.

3.3 A Clean Content Workflow

Markdown should stay Markdown.

Quesby provides:

• structured content directories
• automatic slugs
• ULID-based IDs
• predefined collections
• simple front matter rules

Nothing exotic. A workflow that doesn't collapse the moment you add pages.

3.4 Adding a new article made easy

Creating a new article is as simple as adding a file like:

src/content/posts/01HXYZABCD1234567890--my-first-post/index.md

---
id: 01HXYZABCD1234567890
title: "My First Post"
slug: "my-first-post"
description: "Short summary used for meta tags and previews."
date: "2025-12-09T10:00:00.000Z"
image: "/assets/images/posts/my-first-post/cover.jpg"
category: "guide"
tags: ["static-site", "eleventy", "seo"]
---

Your Markdown content starts here.

And it can be even easier by launching the helper:

npx quesby new post "title-of-the-article"

3.5 A Boilerplate That Doesn’t Dictate Design

The starter includes a neutral, accessible layout system you can extend or scrap entirely.

It works out of the box for:

• blogs
• landing pages
• docs sections
• mixed content sites

But you’re never locked into its visual identity.

4. Architecture: Predictable by Design

The directory structure is intentionally boring:

src/
├─ _data/
│  └─ site.json
├─ _includes/
│  ├─ layouts/
│  └─ partials/
├─ assets/
│  ├─ css/
│  ├─ js/
│  └─ images/
├─ config/
│  ├─ collections.js
│  └─ taxonomies.js
├─ content/
│  ├─ media/
│  ├─ posts/
└─ themes/
   └─ quesby-core-theme/

No hidden pipelines, no magic directories.

If you open the repo six months later, it still makes sense.

5. Performance: Not a Contest, Just Good Defaults

Static sites are fast by default.

Quesby ensures you don’t accidentally sabotage that:

• no unwanted JS
• minimal CSS
• optimized images
• zero cookies
• no external requests unless you add them

Performance isn’t a selling point—it’s a consequence.

6. Privacy by Default

Quesby ships with zero third-party integrations.

• fewer external calls
• fewer legal requirements
• fewer performance penalties
• fewer surprises during audits

Add analytics or embeds only when needed, not because the template assumed them.

7. Developer Experience: Stability Over Flashiness

Quesby’s DX avoids two extremes:

no sprawling configs, no “one-command magic” that hides everything.

You get:

• a stable, understandable codebase
• modular configs
• predictable build behavior
• freedom to extend without digging through abstractions

DX should support development, not add ceremony around it.

8. Who Quesby Is For

Quesby fits developers who:

• build static or content-driven sites
• prefer explicit structure over convention-heavy automation
• want SEO and images solved without plugins everywhere
• like Eleventy but want an ecosystem around it
• want a workflow they can audit and override

If you’re building a full web app, you’ll want something else.

If you’re building a website, this will probably feel more natural.

9. Closing Thoughts

Static sites don’t need complicated tooling, but they do benefit from structure and good defaults.

Quesby sits in that middle ground:

lightweight, stable, and focused on solving the recurring problems of static-site development without dragging in an entire ecosystem built for different use cases.

If that sounds like the right balance for your next project:

npm create quesby@latest

Quesby doesn’t try to redefine web development.

It just tries to make building websites feel sane again.