QuestBoard: Turn Your Notion Workspace Into a Full RPG

This is a submission for the Notion MCP Challenge

See the generated workspace:
QuestBoard Notion

What I Built

QuestBoard turns a Notion page into a playable RPG-style productivity system.

Instead of giving you another flat task list, it creates a workspace where:

• real tasks become quests
• neglected areas become new quest targets
• completed work turns into XP, levels, streaks, and achievements
• bigger pressure points can become boss battles
• weekly progress becomes a recap page written like a story chapter

The important part is that this is not just themed copy pasted into Notion. QuestBoard is MCP-native from end to end. It uses Notion MCP to create the workspace, create and update records, build hosted views, sync progression, log automation runs, and support review/correction loops.

Why It Is Useful

The core problem I wanted to solve was this: most productivity systems are good at storing work, but weak at making progress felt.

QuestBoard tries to make motivation, pressure, and momentum visible inside a workspace people already use:

• weak skill areas are easier to spot
• small wins still feel meaningful because they award progression
• recurring inconsistency shows up as stale quests, not invisible drift
• a user can review and correct generated content instead of treating AI output as automatically trusted

It also works beyond the canned showcase flow. A real user can onboard with:

• a real goal
• what success looks like
• a real time budget
• preferred pacing
• constraints
• motivation
• optional domain context for niche tools or jargon

That profile is saved into Notion and used to shape future quests.

How A User Actually Gets Value

The real-user loop is:

1. Connect hosted Notion MCP and point QuestBoard at a blank Notion page.
2. Run guided onboarding so QuestBoard captures the user’s real goal, time budget, focus area, constraints, and motivation.
3. QuestBoard creates the full workspace in Notion.
4. The user works mostly in Notion: reviewing quests, moving them through status, and watching progression update.
5. QuestBoard syncs XP, levels, streaks, skills, achievements, run logs, and review state.
6. Weekly recaps and review workflows turn the workspace from “AI generated pages” into an operating system the user can keep using.

For ambiguous or niche goals, onboarding can optionally use Exa or Perplexity to ground the saved context before the first quests are generated.

What The Hosted MCP Path Creates

On the hosted path, QuestBoard creates 8 databases and 14 named views across 8 hosted view types.

Core databases:

• Player Profile
• Quest Board
• Skill Trees
• Achievement Log
• Hero Roster
• Adventure Recaps
• Runs
• Review Queue

Hosted views:

• Hero Dashboard
• Quest Ledger
• Quest Map
• Quest Calendar
• Quest Timeline
• Quest Cards
• XP Progress
• Skill Focus
• Skill Board
• Trophy Case
• Hero Roster
• Story Archive
• Run Center
• Review Queue

That is what makes the product feel like a real Notion system instead of a terminal tool that happens to write pages.

Video Demo

The video focuses on the strongest hosted path:

• create the workspace on a blank Notion page
• Questboard generated views and structure
• Questboard do quest generation and progression
• QuestBoard syncs Notion changes back into the game state

Show Us The Code

bO-05 / questboard

QuestBoard

Turn your Notion workspace into an RPG. QuestBoard is a Python app that uses Notion MCP to create and operate a gamified workspace with quests, boss battles, skill trees, XP, recaps, runtime automation, and human review workflows.

What It Does

• Creates a full QuestBoard workspace inside Notion
• Guides first-time setup with questboard onboard so a real goal, time budget, motivation, and constraints shape the workspace
• Generates quests from your focus areas and skill gaps
• Creates boss battles for neglected skills or habits
• Tracks XP, leveling, streaks, and achievements
• Writes weekly recaps with AI or deterministic fallbacks
• Can optionally ground ambiguous goals with Exa or Perplexity before the first quests are generated
• Logs automation runs in Runs
• Routes generated output through a Review Queue
• Supports revision loops for reviewed quests and recaps
• Runs a policy-based runtime loop with questboard runtime and questboard watch

Notion MCP Integration

QuestBoard is MCP-native. Notion…

View on GitHub

Key files:

File	What it does
src/cli.py	User-facing commands for setup, onboarding, doctor, sync, runtime, review, revision, and demo flows
src/setup_workspace.py	Builds the Notion workspace, schemas, hosted views, and seed data
src/mcp_client.py	MCP wrapper for hosted vs self-hosted Notion operations
src/onboarding.py	Goal grounding, optional research, and context-brief generation
src/engines/quest_generator.py	Quest generation, boss generation, JSON repair, and fallback templates
src/engines/xp_engine.py	XP, leveling, streaks, achievements, and progression reconciliation
src/engines/recap_writer.py	Weekly recap generation and stale quest patrol
src/runtime.py	Policy-based runtime planning, watch mode, and recurring control-loop behavior
src/operations.py	Review Queue operations and review-surface reconciliation
src/revision.py	Correction-loop revision from review notes

Local validation for the release snapshot reached 130 passed.

How I Used Notion MCP

QuestBoard is built around Notion MCP, not lightly assisted by it.

Every important operation goes through MCP:

MCP capability	How QuestBoard uses it
Create database	Builds the full multi-database workspace
Create pages	Creates quests, boss battles, recaps, player records, run logs, and review items
Update page	Syncs quest status, XP, levels, streaks, and review state
Create view	Builds the hosted product surfaces like Quest Map, XP Progress, Hero Dashboard, Run Center, and Review Queue
Search	Finds player, quest, skill, run, and review records across the workspace
Fetch	Reads schema and page state to drive generation, sync, and runtime decisions
Create comment	Adds progression flavor, warnings, and operational commentary
Move pages	Supports archival and organization flows

I also intentionally supported both hosted and self-hosted MCP paths:

• hosted MCP is the strongest product/demo path because it can create the richer view suite
• self-hosted MCP is still valuable for local validation and token-based setup

Reliability And Hardening

I spent a large part of the build on making the project less fragile:

• questboard doctor provides a read-only workspace health check
• questboard hosted-login makes the hosted OAuth path usable without hand-building tokens
• setup accepts full Notion URLs, not just raw IDs
• rerunning setup can repair an older saved workspace instead of blindly trusting stale local metadata
• QuestBoard has deterministic fallback generation when model output is malformed or unavailable
• generated content is reviewable, correctable, and revision-friendly through Review Queue and revision flows
• Run Center records operational history instead of hiding it

That matters because an MCP project should not just generate a cool first page. It should keep behaving coherently once the workspace is alive.

Closing

QuestBoard is my attempt to make Notion feel less like a storage layer and more like a playable progression system.

The goal was not only to make something flashy. The goal was to make a workspace where motivation, progress, governance, and automation all become visible inside Notion itself.