Some projects exist to show off.
Others exist to work.

D&D5eTools.com firmly belongs to the second camp—and that’s exactly the point. This is a deliberately framework-free, static web application built to solve real tabletop problems for Dungeons & Dragons 5e players and Dungeon Masters. No React. No build pipeline. No dependency graph threatening to achieve sentience. Just HTML, CSS, and JavaScript doing what they’ve always done best when treated with respect.

For employers, recruiters, and developers, this project is a quiet but confident demonstration of fundamentals: architectural clarity, readable logic, scalable structure, and the discipline to stop adding features when the problem is already solved.

What the Project Actually Is

At its core, D&D5eTools.com is a collection of focused utilities designed to be used at the table—not admired in a portfolio slideshow and forgotten. Each tool addresses a specific friction point in 5e character creation and prep, and each is intentionally narrow in scope.

There are three primary components:

Ability Score Generator

Implements the classic 4d6, drop-the-lowest method in a way that is transparent, predictable, and rule-faithful. Dice rolls are explicit. Calculations are readable. Nothing is hidden behind abstractions that would make a rules-lawyer suspicious.

Physical Stat Generator

Age, height, and weight generation based on race-specific rules, implemented using parsed dice expressions on the client side. This isn’t random fluff—it’s encoded rule logic, translating book tables into deterministic JavaScript behavior that mirrors tabletop expectations.

Pre-Generated Character Gallery

A static, filterable character gallery that links portraits and PDFs through deterministic naming conventions. No database. No API. Characters scale by adding files, not rewriting code. This is content-driven architecture in its simplest and most durable form.

Each tool stands alone, yet the site feels cohesive—because the structure underneath it is.

Design Philosophy: Calm, Structured, and Boring on Purpose

The visual design of D&D5eTools.com makes a conscious decision: clarity over flash.

Typography favors readability. Layouts are predictable and consistent. Components repeat with purpose, not laziness. The UI isn’t trying to compete with character art or dice trays—it exists to stay out of the way while players make decisions.

Shared elements like headers and footers are abstracted into reusable HTML fragments, reducing duplication and enforcing consistency across pages. This keeps the site maintainable without introducing templating engines or build tools that would complicate deployment for a project that doesn’t need them.

CSS is organized by responsibility rather than novelty. Global styles handle structure and typography, while tool-specific rules live where they belong. There’s no cascade chaos, no mystery overrides, and no “temporary” rules that somehow survived three refactors.

It’s a design that respects the user’s time—and the next developer’s sanity.

JavaScript Without the Safety Net (And Why That Matters)

This project intentionally avoids frameworks, which means the JavaScript has nowhere to hide.

Logic is broken into small, single-purpose modules. Dice rolling, data parsing, and generation logic live separately from DOM rendering. UI updates are explicit. State is managed directly, not smuggled through lifecycle hooks or magic bindings.

Functions are named clearly. Inputs and outputs are obvious. Side effects are controlled. You can open a file and understand what it does without reverse-engineering an ecosystem.

This approach demonstrates something increasingly rare: confidence in core JavaScript. Not nostalgia—competence. It’s proof that I understand what frameworks abstract away, because I’ve built the layers myself.

Static Doesn’t Mean Simple

One of the most telling aspects of D&D5eTools.com is how it scales without pretending to be a full-stack application.

Characters, images, and PDFs follow predictable naming and directory conventions. Add new assets, and they’re automatically picked up by the existing logic. There’s no configuration file to update, no schema to migrate, and no brittle glue code waiting to break.

This is scalability through discipline rather than infrastructure. It’s the kind of thinking that comes from understanding that not every problem benefits from a backend—and that overengineering is still engineering debt.

Compatibility, Longevity, and Real-World Use

The project includes shims and defensive coding where appropriate to maintain compatibility across environments. That choice is intentional. Real users don’t all run the latest browser, and real utility sites should degrade gracefully instead of failing loudly.

This isn’t bleeding-edge JavaScript chasing novelty. It’s stable, portable code meant to last. The kind of code you can revisit years later without needing a migration guide and a support group.

What This Project Signals to Employers

D&D5eTools.com demonstrates:

• Strong command of HTML, CSS, and JavaScript fundamentals
• Thoughtful separation of concerns without frameworks
• Clean, maintainable UI composition
• Data-driven logic implemented client-side
• Scalable content architecture without unnecessary infrastructure
• Good judgment about when not to add complexity

Most importantly, it shows intent. Every choice here is deliberate. Nothing is accidental. Nothing is cargo-culted.

Final Word

D&D5eTools.com isn’t flashy, and it isn’t trying to be. It’s confident, restrained, and built to last—like a well-balanced character sheet that doesn’t need homebrew patches to function.

If you’re looking for proof that I can design and build practical, maintainable web tools without leaning on a framework as a crutch, this project makes the case quietly—and lets the work speak for itself.

No glitter.
No overengineering.
Just solid tools, rolling straight down the middle.