Some projects chase trends. QuestKeeper sharpened its sword, packed its rations, and walked the road the long way—by design.

Built in 2018 as a full-stack PHP and MySQL web application, QuestKeeper is a Dungeons & Dragons 5e character tracker that embraces traditional web fundamentals. No modern frameworks. No scaffolding magic. Just sessions, SQL, structured includes, and deliberate logic layered one piece at a time. It’s a utility app first, a portfolio statement second—and that order matters.

For employers, developers, and recruiters, QuestKeeper demonstrates something increasingly rare: someone who understands how the web actually works.

What QuestKeeper Does

QuestKeeper allows users to register, authenticate, and manage D&D 5e characters inside a protected member area. Each character sheet stores ability scores, skills, saving throws, proficiencies, and level-based statistics, all persisted in a relational database and dynamically rendered in the browser.

This is not a static demo or mockup. It is a functional, stateful application with real users, real data, and real rules.

Application Structure & Architecture

The project follows a clean, conventional PHP structure that prioritizes clarity and maintainability:

• Shared logic and configuration live in a dedicated includes/ directory
• Environment-specific database credentials are abstracted and excluded from version control
• Constants and helper functions are centralized
• Public pages and protected routes are clearly separated

The layout reflects a disciplined approach to server-side development—one that scales mentally before it scales technically.

Authentication & Session Control

QuestKeeper implements a complete authentication flow:

• User registration and login
• Session initialization and teardown
• Access control for protected pages
• Server-side validation and error handling

Passwords are hashed using MD5, which is openly documented in the README as a legacy choice reflective of the project’s era. Importantly, the documentation also explains how modern hashing (password_hash) would replace it today. That transparency signals awareness, not oversight.

Database Design & Data Flow

At its core, QuestKeeper is a thoughtfully constructed CRUD application:

• Character data is stored relationally
• SQL queries are structured, readable, and purpose-built
• Reusable database functions handle persistence
• Character creation, retrieval, updates, and deletion are fully implemented

The schema supports the layered complexity of a D&D character sheet without becoming brittle or overengineered—a balance that takes experience to strike.

Rules-Driven Character Logic

D&D character sheets are rule engines in disguise, and QuestKeeper treats them accordingly.

• Ability modifiers are calculated dynamically from base stats
• Skill bonuses combine modifiers and proficiency bonuses
• Saving throws reflect class proficiencies
• Proficiency bonuses scale automatically with character level

These calculations are handled in dedicated PHP includes, keeping business logic isolated, readable, and testable. The code reflects a real understanding of the D&D 5e ruleset—not just the math, but the intent behind it.

Dynamic Updates with AJAX

QuestKeeper enhances usability without abandoning server-rendered principles:

• Character data loads dynamically
• Updates occur without full page reloads
• JSON responses keep client-side logic lightweight

This hybrid approach delivers responsiveness while preserving clarity—proof that interactivity doesn’t require a JavaScript framework to be effective.

Interface & Front-End Choices

The UI favors function over flash:

• Form-driven layouts modeled after traditional character sheets
• Straightforward CSS focused on readability
• Bootstrap used pragmatically to accelerate layout consistency

The result is an interface that feels like a tool, not a toy—exactly what a character manager should be.

Operational & Portfolio Maturity

Several quiet details elevate the project:

• Example configuration files instead of hard-coded secrets
• Dedicated PHP error logging for debugging
• Clear README documentation explaining scope and limitations
• Conscious framing as a portfolio artifact rather than a production claim

These choices demonstrate professional restraint and an understanding of real-world development constraints.

Why QuestKeeper Still Matters

QuestKeeper doesn’t rely on buzzwords to impress. It demonstrates foundational competence where it counts:

• HTTP request lifecycles
• Session management
• Relational data modeling
• Business logic separation
• Incremental enhancement

For recruiters and employers, this project shows someone who can build systems—not just assemble interfaces.
For developers, it’s a reminder that strong fundamentals age better than trends.

QuestKeeper is classic for a reason.
Every stat is earned. Every rule is respected.
And nothing here rolled with advantage it didn’t deserve.