DEV Community: Lux Seminare

How to Build a Learning Resource in Notion (Step-by-Step)

Lux Seminare — Tue, 02 Jun 2026 08:31:57 +0000

Most developers have the same problem with learning: the list keeps growing and the progress doesn't.

You bookmark a course. You buy a book. You save an article to read later. Three months pass and none of it has moved. The problem isn't motivation — it's that there's no system connecting what you want to learn to where you actually are with each resource.

A Notion learning resource tracker fixes this. Not by adding more friction, but by giving you a single place where everything you're learning lives — with progress calculated automatically, filtered views that surface what's active versus what's stalled, and a lesson-level relation that tracks exactly how far into each resource you've gone.

This guide builds the exact system used in DevHub's Learning Resources database, based on real structure you can replicate today.

What You're Building

A Learning Resources database in Notion with:

Four resource types tracked in one place — courses, books, articles, tutorials
Automatic progress calculation based on completed lessons versus total length
A completion checkbox that updates itself when status changes
Five filtered views covering every angle you need — active learning, pipeline by type, topic-specific filters, and reading backlog
A relation to a Lessons database so progress reflects real unit-level completion, not gut estimates

Who This Is For

Developers, engineers, and self-taught learners who:

Buy courses and never finish them
Have a reading list that grows faster than it shrinks
Want learning tracked alongside their actual work rather than in a separate app
Need to see what's active right now versus what's queued versus what's done

Step 1: Create the Learning Resources Database

Create a new full-page database in Notion. Name it Learning Resources.

This database is the core. Everything else — the lessons, the views, the formulas — connects back to it.

Step 2: Set Up the Core Properties

Delete Notion's default properties and add the following exactly as listed.

Name (Title)

Keep the default Title property. Rename it to Name if it isn't already.

Write resource names specifically enough to be useful when scanning a list. "JavaScript Course" is not useful. "The Odin Project — Full Stack JavaScript" is.

Link (URL)

Add a URL property named Link.

Paste the direct URL to the course, article, book page, or documentation. This makes every resource one click away from the database — no hunting through bookmarks.

Type (Select)

Add a Select property named Type.

Options:

Article
Book
Course
Tutorial

Type determines how you filter and group your resources. The Learning Pipeline view groups by Type so you can see at a glance whether your active learning is balanced across formats or concentrated in one area.

Status (Select)

Add a Select property named Status.

Options:

To Read
In Progress
Completed

Keep exactly these three options and these exact names — the formulas reference them directly. If you rename them, the Is Done? formula and the filtered views will break.

Status is the primary property you update as you move through a resource. Everything else — progress, filtering, board placement — flows from this field.

Tags (Multi-select)

Add a Multi-select property named Tags.

Tags serve two purposes: skill level and topic. Use them to categorize resources so topic-specific filtered views work correctly.

Skill level tags: Beginner / Intermediate / Advanced

Topic tags — add what's relevant to your stack: JavaScript / TypeScript / Python / React / Node.js / CSS / SQL / Docker / Git / System Design / Clean Code / Data Science / Documentation / Testing / DevOps

Keep your tag list under 30 total. More than that and tags start overlapping — you'll forget which one you used on a specific resource and filtering becomes unreliable.

The JavaScript Courses view and Books to Read view both use Tags as filter conditions. Any tag you want to filter by later needs to be added to entries consistently.

Length (Number)

Add a Number property named Length.

This is the total number of lessons, chapters, modules, or sections in the resource. It's the denominator in the progress calculation.

How to set it per type:

Course: total number of videos or modules
Book: total number of chapters
Tutorial: total number of sections or steps
Article: set to 1 — articles are single-unit resources

If you don't know the exact number yet, estimate and update it later. The progress formula handles the calculation — you just need a reasonable denominator.

Learning Hours Log (Number)

Add a Number property named Learning Hours Log.

Track total hours spent on this resource. Update it manually after each study session — add to the existing number, don't overwrite it.

Over time this gives you a running record of where your learning hours actually go. A course with 10 hours logged that's still at 20% completion tells you something different than a course with 2 hours logged at the same progress.

Step 3: Create the Lessons Database

Before setting up the Lessons relation in Learning Resources, you need to build the database it connects to.

Create a second full-page database. Name it Lessons / Chapters / Course Modules.

Add these properties:

Property - Type - Purpose

Name - Title - The lesson or chapter name

Completed - Checkbox - Mark when done

Learning Resource - Relation - Links back to Learning Resources

When you create the relation in this database pointing to Learning Resources, toggle on "Show on Learning Resources" — this creates the bidirectional connection automatically.

How to use it: when you start a new course or book, add each lesson or chapter as a separate row in this database and link it to the parent resource. As you complete each one, check the Completed checkbox. The Progress formula in Learning Resources reads this count automatically.

Step 4: Add the Lessons Relation to Learning Resources

Back in your Learning Resources database, add a Relation property named Lessons.

When setting it up:

Search for and select your Lessons / Chapters / Course Modules database
Toggle on "Show on Learning Resources"

This creates a two-way relation. Each Learning Resource knows which lessons belong to it. Each lesson knows which resource it belongs to.

Step 5: Add the Daily Log Relation

Add a second Relation property named Daily Log.

Link this to your Daily Log database if you have one. This connects your learning activity to the days you actually worked on it — so when you look at a daily log entry, you can see which resources you touched that day, and when you look at a resource, you can see which days had activity on it.

If you don't have a Daily Log database yet, leave this property empty for now. Add it when you build one.

Step 6: Add the Two Formulas

These are the two formulas that make the database intelligent rather than just a list.

Formula 1: Is Done? (Checkbox)

Add a Formula property named Is Done?

Change the output type to Checkbox.

The formula:

prop("Status") == "Completed"

What it does: Returns a checked checkbox when Status is "Completed" and an unchecked checkbox when it's anything else.

Why use a formula instead of just reading the Status field directly: The Is Done? checkbox gives you a clean binary signal that works cleanly in rollups from other databases. If your Character Sheet or a Projects database needs to count completed learning resources, rolling up a checkbox is simpler and more reliable than filtering by a Select property's text value.

One thing to watch: The formula checks the exact string "Completed" — capital C. If your Status option is named differently, update the formula string to match.

Formula 2: Progress (Number)

Add a Formula property named Progress.

Change the output type to Number. In the number format settings, set it to display as a percentage.

The formula:

if(
  empty(prop("Lessons")) or prop("Length") == 0,
  0,
  prop("Lessons").filter(
    current.prop("Completed") == true
  ).length() / prop("Length")
)

What each part does:

if(empty(prop("Lessons")) or prop("Length") == 0, 0, — guard clause. If no lessons are linked yet or Length is 0, return 0 instead of a division error or a misleading percentage.

prop("Lessons").filter(current.prop("Completed") == true).length() — counts only the lessons marked as Completed in the related Lessons database. This is the numerator.

/ prop("Length") — divides completed lessons by the total length you entered manually. This is the denominator.

The result: A percentage from 0 to 1 that Notion displays as 0% to 100% in percentage format. Updates automatically every time you check off a lesson.

Why this approach works better than a manual percentage field: Manual percentage fields require you to remember to update them. This formula reads from actual lesson completion — so the progress number always reflects real work, not an estimate you set and forgot to change.

One thing to watch: Progress is based on completed lessons divided by the Length you entered manually. If Length is set to 10 but the course actually has 15 lessons, the progress will show 100% before you've finished. Keep Length accurate as you go through the resource.

Step 7: Build the Five Views

These five views give you different angles on the same data — each one answers a different question about your learning without you having to filter manually each time.

View 1: All Learning Resources (Table View)

This is your master view. Everything visible, nothing filtered.

Properties to show: Name, Type, Status, Tags, Link, Length, Progress, Learning Hours Log, Lessons, Daily Log

Sort: Name, ascending

Use this view for initial setup, bulk editing, and your monthly review when you want to see everything at once.

View 2: Active Learning (Gallery View)

View type: Gallery

Filter: Status ≠ Completed

Sort: Status, ascending

Properties shown on cards: Name, Status, Progress
This is your daily working view. It shows everything you haven't finished — both In Progress and To Read resources — sorted so In Progress appears before To Read.

The gallery format makes the Progress property visible as a progress bar on each card, giving you a visual read on how far along each active resource is without clicking into anything.

Keep this view clean. If it has more than five or six cards, you have too many active resources. Reduce to three In Progress items maximum — more than that and you're context switching between learning the same way you context switch between tasks.

View 3: Learning Pipeline (Board View)

View type: Board

Group by: Type

Filter: Status ≠ Completed

Sort: Progress, ascending

Hide empty groups: On

This view shows your incomplete resources organized by format type — Courses in one column, Books in another, Articles and Tutorials in theirs. Resources with the lowest progress appear at the top of each column.

Use it on Mondays for a weekly learning check. The column structure tells you immediately whether your learning is spread across formats or piled up in one area. Four courses in progress and zero books being read is a pattern worth noticing.

The ascending progress sort surfaces the resources you've barely started before the ones you're close to finishing — useful for deciding whether to push through something that's almost done or restart something you've stalled on.

View 4: JavaScript Courses (List View)

View type: List

Filters: Type = Course AND Tags contains JavaScript

Properties shown: Name, Tags

This is an example of a topic-specific filtered view. It shows only courses tagged with JavaScript, regardless of status — so you can see everything in that topic area at once, including completed ones.

Build similar views for any technology you're actively developing skills in. The pattern is always the same: Type = Course (or Book, or Tutorial) AND Tags contains [your topic].

Examples you might add based on your stack:

Python Books: Type = Book AND Tags contains Python
React Tutorials: Type = Tutorial AND Tags contains React
System Design Resources: Tags contains System Design (any type)

View 5: Books to Read (List View)

View type: List

Filters: Type = Book AND Status = To Read

Properties shown: Name

Your reading backlog. Clean and minimal — just the titles, nothing else.

This view answers one question: what books haven't I started yet? When you finish a book and mark it Completed, it disappears from this view automatically. When you add a new book with Status = To Read, it appears automatically.

Build similar views for other types if the backlog gets large:

Courses to Start: Type = Course AND Status = To Read
Articles to Read: Type = Article AND Status = To Read

Step 8: Add Tags to Existing Resources and Test

Before the views are useful, the data needs to be accurate.
Go through your existing resources (or add a few test entries) and:

Set the correct Type for each
Set Status to To Read, In Progress, or Completed accurately
Add at least one skill level tag (Beginner/Intermediate/Advanced) and one topic tag
Fill in Length with the number of lessons, chapters, or sections
Create lesson entries in the Lessons database for any In Progress resource and link them back

Once you have a few entries set up correctly, open each view and verify the filters are working. The Active Learning gallery should show only incomplete resources. The Learning Pipeline board should group by type with no Completed items. JavaScript Courses should show only items with both conditions met.

How to Use This System Day to Day

When you find a new resource:
Add it to Learning Resources with Status = To Read. Set Type, add Tags, fill in Length. Link added, resource captured, done.

When you start something:
Change Status to In Progress. Create the lesson entries in your Lessons database and link them to the resource. Now progress tracking is live.

During a study session:
Check off completed lessons in the Lessons database. Watch the Progress formula update automatically. Log your hours in Learning Hours Log — add to the existing number.

When you finish:
Change Status to Completed. Is Done? auto-checks. The resource disappears from Active Learning and Learning Pipeline. It stays visible in All Learning Resources as a permanent record.

Weekly (Monday, 5 minutes):
Open the Learning Pipeline board. Check if anything In Progress has stalled — low progress, no recent lesson completions. Decide honestly: restart it, pause it, or abandon it. Pull something from To Read into In Progress if you have fewer than three active items.

Why This Works Better Than a Simple List

A plain list of resources tells you what you want to learn. This system tells you where everything actually is.

The Progress formula reads from real lesson completion — not from an estimate you set and forgot to update. The Is Done? formula creates a reliable completion signal that works in rollups from other databases. The five views answer five different questions without any manual filtering on your part.

The lesson-level relation is the most important structural decision in the system. It means progress is earned, not estimated. You can't move the percentage by convincing yourself you remember the material. You move it by checking off the work.

If you want this database pre-built and connected to a complete developer workspace — including daily log integration, character sheet rollups, and the full DevHub system — the free version is available at no cost.

Free download, no credit card required.

What's been sitting on your learning list the longest without moving? Drop it in the comments.

Notion Formula Cheat Sheet: Every Formula Type Developers Actually Need (2026)

Lux Seminare — Mon, 01 Jun 2026 08:08:50 +0000

Notion Formula Cheat Sheet for Developers (2026)

Notion formulas follow consistent patterns. Once you learn the pattern, most formulas become variations of something you've already seen.

Most formula guides organize by use case -- "formulas for project management," "formulas for habit tracking." This one organizes by pattern type, because understanding the structure is what lets you build formulas you haven't seen before, not just copy ones you have.

What this guide covers:

Basic syntax rules that prevent 90% of errors
Text, number, date, and boolean formulas
Conditional logic patterns for if statements
Rollup-based formulas
Two complete production-ready formulas used in real developer workflows
Troubleshooting reference for the most common Notion formula errors

Why Developers Need Notion Formulas

Standard Notion databases are static. You add data, you read data, nothing moves on its own. Formulas change that -- they turn your workspace into something that calculates, flags, labels, and responds to the data you enter.

For a developer productivity system specifically, formulas are what make the difference between a task list and a system. Without them, you're manually updating fields that could update themselves. With them, your workspace surfaces what needs attention, tracks progress automatically, and rewards completion without any extra input from you.

Part 1: Basic Syntax Rules for Notion Formulas

Three rules that prevent most Notion formula errors before they happen.

Rule 1: String Values Use Double Quotes

if(("Status") == "Done", "Incomplete", "Complete")

Text comparisons in Notion formulas always use double quotes. Single quotes throw an error with no helpful message.

Rule 2: Nested If Statements Close With Matching Parentheses

if (A, "x", if (B, "y", if (C, "z", "default")))

Every if( needs a closing ). Three nested if statements need three closing parentheses at the end. Count your opens and closes before saving -- this is where most Notion formula syntax errors hide.

Rule 3: Empty and Zero Are Not the Same

empty("Due Date") //true when the date is field blank
("Number Field") == 0 //true when the field contains zero

Use empty() to check for blank fields. Use == 0 to check for the number zero. Confusing these produces formulas that return wrong results silently -- no error, just incorrect output.

Part 2: Notion Text Formulas

Concatenate Two Properties

("First Name") + " " + ("Last Name")

Returns: Text -- "Alex Chen"

When to use: Combining name fields or any two text properties into a single display value.

Concatenate Text With a Number in Notion

"Level " + format("Level Number")

Returns: Text -- "Level 7"

When to use: Adding static text before or after a number. The format() function converts the number to text -- without it, Notion throws a type mismatch error.

Convert Text to Uppercase

upper("Status")

Returns: Text — "DONE"

When to use: Standardizing text display in headers or labels when source data has inconsistent casing.

Check if a Notion Text Field Contains a Keyword

contains("Tags"), "urgent"

Returns: Boolean — true or false

When to use: Filtering or flagging entries that include a specific word in a text field. Case-sensitive — "urgent" and "Urgent" return different results.

Show a Fallback When a Field Is Empty

if(empty("Project Name"), "No project assigned", "Project Name")

Returns: Text — the project name or the fallback string

When to use: Preventing blank cells on dashboards where every row should display something meaningful.

Count Characters in a Notion Text Field

length("Notes")

Returns: Number — 142

When to use: Tracking note length or flagging fields that are too short to be useful.

Part 3: Notion Number Formulas

Basic Arithmetic in Notion

("Revenue") - ("Cost")

Returns: Number

When to use: Any calculation involving two number properties. Supports +, -, *, /.

Round Numbers in Notion Formulas

round("Score")

Returns: Number — 73 from 72.8

When to use: Cleaning up decimal results from division. round() rounds to nearest, floor() always rounds down, ceil() always rounds up.

Calculate a Percentage in Notion

floor(("Completed" / "Total") * 100)

Returns: Number — 68

When to use: Progress percentages and completion rates. floor() prevents decimal output.

Clamp a Number Within a Range

min(max("Progress", 0), 100)

Returns: Number — always between 0 and 100

When to use: Preventing progress percentages from going below 0 or above 100 when source data produces out-of-range values.

Get the Maximum of Two Values

max("Estimated Hours", "Actual Hours")

Returns: Number — the larger of the two

When to use: Comparing two number properties and surfacing whichever is larger. min() works the same way for the smaller value.

Part 4: Notion Date Formulas

Get Today's Date in Notion

now()

Returns: Date — current date and time

When to use: As the reference point in any Notion date calculation. Updates automatically every time Notion recalculates.

Calculate Days Between Two Dates in Notion

dateBetween("Due Date", now(), "days")

Returns: Number — positive if Due Date is in the future, negative if it's in the past

When to use: Calculating days until a deadline or days overdue. Result is Due Date minus now() — so future dates give positive numbers.

Add Days to a Date in Notion

dateAdd("Start Date", 7, "days")

Returns: Date — seven days after the start date

When to use: Calculating end dates, review dates, or any date a fixed interval after another. Supports "days", "weeks", "months", "years".

Format a Notion Date as Readable Text

formatDate("Due Date", "MMM DD, YYYY")

Returns: Text — "May 23, 2025"

When to use: Displaying dates in a specific format inside concatenated strings. Format codes: MMM = short month name, MMMM = full month name, DD = day with leading zero, YYYY = four-digit year.

Extract the Month From a Date in Notion

month("Created Date")

Returns: Number — 1 through 12

When to use: Grouping entries by month or filtering for a specific month. day(), year(), and hour() work the same way.

Check if a Notion Date Is in the Past

dateBetween("Due Date", now(), "days") < 0

Returns: Boolean — true if the date has passed

When to use: The foundation of overdue detection in Notion. Combine with if() to label or flag entries automatically.

Days Since an Entry Was Created

dateBetween(now(), "Created time", "days")

Returns: Number — days since creation

When to use: Age tracking and stale entry detection. Note the reversed argument order — now() first gives a positive number for past dates.

Part 5: Notion Conditional Logic — If Statement Patterns

Basic Notion If Statement

if("Status" == "Done", "✓ Complete", "In progress")

Returns: Text — one of two values based on the condition

When to use: Any binary labeling in Notion — done/not done, overdue/upcoming, high/low.

Nested If Statement in Notion (Multiple Conditions)

if("Priority" == "High", "🔴 Critical",
if("Priority" == "Medium", "🟡 Normal",
if("Priority" == "Low", "🟢 Low",
"No priority")))

Returns: Text — one of four possible labels

When to use: More than two possible outputs. Each additional condition adds one more nested if(). Always end with a default value as the last argument.

Notion And Condition

if(and("Status" == "Done", "Priority" == "High"), "High value win", "")

Returns: Text — label only when both conditions are met

When to use: Flagging entries that meet multiple criteria simultaneously. Empty string "" leaves the cell blank when conditions aren't met.

Notion Or Condition

if(or("Status" == "Overdue", "Status" == "Blocked"), "⚠️ Needs attention", "")

Returns: Text — label when either condition is met

When to use: Surfacing entries that match any one of several problem states.

Notion If Statement With Empty Guard

if(empty("Due Date"), "No deadline",
if(dateBetween("Due Date", now(), "days") < 0, "Overdue", "On track"))

Returns: Text — three possible states

When to use: Always guard against empty dates first when using date properties in Notion — skipping this causes errors on any row without a date filled in.

Ternary-Style If in Notion Formulas 2.0

prop("Score") >= 80 ? "Pass" : "Fail"

Returns: Text — "Pass" or "Fail"

When to use: Simple binary conditions where the long-form if() syntax is unnecessary. Only works in Formulas 2.0.

Part 6: Notion Boolean Formulas

Check if a Checkbox Is Checked in Notion

("Done") == true

Returns: Boolean

When to use: Using a checkbox property as a condition inside a larger Notion formula.

Convert a Boolean to Text in Notion

if("Is Active", "Active", "Inactive")

Returns: Text — readable label from a checkbox value

When to use: Displaying checkbox state as text in a summary or label column.

Part 7: Notion Rollup-Based Formulas

Rollups pull aggregated data from related databases. Set up the rollup first, then reference its result inside a formula.

Progress Percentage From Rollup

if("Total Tasks" == 0, 0,
floor(("Done Tasks" / "Total Tasks") * 100))

Requires:

Rollup "Total Tasks": Count all, relation to Tasks database
Rollup "Done Tasks": Count values where Status = Done

Returns: Number — 0 to 100

Flag if Any Related Item Needs Attention

if("Open Issue Count" > 0, "⚠️ Has open issues", "✓ On track")

Requires:

Rollup "Open Issue Count": Count values where Status = Open

Returns: Text — project-level health indicator that updates automatically

Average Score Across Related Entries

round("Average Score")

Requires:

Rollup "Average Score": Average of Score property, relation to relevant database

Returns: Number — rounded average across all related records

Part 8: Two Complete Production-Ready Notion Formulas

Formula 1: Project Progress With Visual Bar

This Notion formula shows project completion as both a percentage and a visual progress bar. It handles empty projects, backlog items, and on-hold work automatically without errors.

Setup:

Add Rollup "Total Tasks" — Count all from Tasks relation
Add Rollup "Completed Tasks" — Count values where Status = Done
Add a Formula property named "Progress"

if(Total Tasks > 0 and Completed Tasks == Total Tasks, "100%",
if(Status == "backlog" or Status == "on hold", "0%",
if(Total Tasks > 0,
  let(
    completed_val, if(empty(Completed Tasks), 0, toNumber(Completed Tasks)),
    total_val, if(empty(Total Tasks), 0, toNumber(Total Tasks)),
    percentage, round(completed_val / total_val * 100),
    progress_blocks_count, floor(percentage / 10),
    filled_bar, (substring("", 0, progress_blocks_count)),
    empty_bar, (substring("", 0, 10 - progress_blocks_count)),
    format(percentage) + "% " + filled_bar + empty_bar
  ),
"0%")))

Output example: 70% ███████░░░

Key behaviors:

Projects where all tasks are done snap cleanly to 100% without rounding errors
Backlog and On Hold projects always show 0% regardless of task count
Empty projects return 0% without throwing a division error
let() scoping keeps each calculation readable and avoids redundant computation

One thing to watch: The Status check references your exact Status option names. If your options use different casing — "Backlog" vs "backlog" — update the formula strings to match character for character.

Formula 2: Automatic Task Value in Notion

This Notion formula assigns a point value to each task based on priority automatically — no manual entry required every time you create a task.

Setup:

Confirm a Select property called "Priority" with options: Low, Medium, High
Add a Formula property named "Task Value"

if(Priority == "High", 10, if(Priority == "Medium", 5, 1))

Output: High = 10 points, Medium = 5 points, Low or unset = 1 point

Low priority tasks return 1 rather than 0 — every completed task contributes something regardless of how it was prioritized.

Roll Task Value up to your Character Sheet:

Relation: Tasks
Property: Task Value
Filter: Status = Done
Calculate: Sum

This gives you a running total of points from completed tasks only — the foundation of a gamified developer productivity system.

One thing to watch: The formula matches exact string values. "HIGH" and "High Priority" won't match "High." Check your Priority option names and update the formula strings to match.

Part 9: Level Progression Formula for Notion (Complete 20-Level Version)

The full exponential level progression formula used in DevHub — 20 levels based on cumulative task points.

if("Total XP" >= 225000, "Level 20: Legendary 🏆",
if("Total XP" >= 185000, "Level 19: Celestial ☄️",
if("Total XP" >= 150000, "Level 18: Ascendant ⚡",
if("Total XP" >= 120000, "Level 17: Apex ⛰️",
if("Total XP" >= 97500, "Level 16: Paragon 💎",
if("Total XP" >= 78000, "Level 15: Oracle 🔮",
if("Total XP" >= 62500, "Level 14: Architect 🗺️",
if("Total XP" >= 50000, "Level 13: Vanguard 🏹",
if("Total XP" >= 40000, "Level 12: Luminary 🌟",
if("Total XP" >= 32000, "Level 11: Virtuoso 🗿",
if("Total XP" >= 25000, "Level 10: Grandmaster 👑",
if("Total XP" >= 18000, "Level 9: Master 🪨",
if("Total XP" >= 13000, "Level 8: Senior 🧭",
if("Total XP" >= 9000, "Level 7: Professional 🛡️",
if("Total XP" >= 6000, "Level 6: Specialist 🔎",
if("Total XP" >= 3500, "Level 5: Adept 🔩",
if("Total XP" >= 2000, "Level 4: Journeyman 📜",
if("Total XP" >= 1000, "Level 3: Apprentice 🛠️",
if("Total XP" >= 500, "Level 2: Novice 🔧",
"Level 1: Beginner ⚙️"))))))))))))))))))))

Requires: A rollup called "Total XP" that sums Task Value from completed tasks only.

Troubleshooting Common Notion Formula Errors

"Property not found"

Property name in the formula doesn't match exactly. Check capitalization and spacing — they must be identical character for character. Rename the property temporarily to something simple like "Test" while debugging to confirm the relation works.

"Type mismatch"

You're combining a number and text without converting. Wrap the number in format() before concatenating: format("Score") + " points"

"Division by zero"

You're dividing by a property that contains zero or is empty. Add a guard clause: if("Total" == 0, 0, "Done" / "Total")

Formula always returns the same value

Your condition is never being met. Test each part separately in a new formula property to isolate where the logic breaks. Check that property names match and that the values you're comparing exist exactly as written in your database.

Rollup shows the wrong count

The filter value on your rollup must exactly match the option name in your database. "Done" and "done" are different values. Open your Status property settings and copy the option name exactly into your rollup filter.

What to Build Next

These formulas work independently — add any one to an existing workspace without touching the others. But they're designed to work together.

The progress formula tells you where your projects stand. The task value formula rewards you for completing the work that moves them forward. The level progression formula turns that accumulated value into a visible measure of your growth as a developer.

That combination — visibility, reward, and progression — is what most productivity systems are missing.

If you want these formulas pre-configured and connected in a complete developer workspace, DevHub includes all of them out of the box. The free version has the full database structure with the formulas already in place.

Free download, no credit card required.

2 Notion Formulas for Productivity

Lux Seminare — Sun, 31 May 2026 07:08:17 +0000

2 Notion Formulas That Actually Get Used Daily

Most Notion formula guides show you what's possible. This one shows you what's practical.

There are hundreds of formulas you could build in Notion. Most of them are clever solutions to problems you don't have. These two are the ones that show up in real workflows every day — the ones that change how the workspace actually feels to use, not just how it looks in a screenshot.

Each one comes with the exact formula, an explanation of what it does and why, and a note on how to set it up from scratch.

A Quick Note on Notion's Formula Versions

Notion updated its formula engine in 2023. If you're on a workspace created after mid-2023, you're using Formulas 2.0, which has slightly different syntax from the original. The formulas below are written for Formulas 2.0. If yours throws an error, the most common culprit is the prop() wrapper — older formula versions don't use it, so remove prop() and reference the property name directly if needed.

Formula 1: Progress Percentage

What it does: Shows what percentage of a project's tasks are complete, displayed as both a number and a visual progress bar. Handles edge cases like empty projects, backlog items, and on-hold work automatically.

Why it matters: A project database with a status column tells you a project is "In Progress." That's not information — that's a label. A progress percentage tells you it's 20% done, or 80% done, which are completely different situations. One number replaces the need to click into a project to understand where it stands.

Where to use it: In a Projects database that has a relation to a Tasks database.

Setup:

In your Projects database, add a Relation property linking to your Tasks database — name it "Tasks"
Add two Rollup properties:

Rollup 1: name "Total Tasks" — Relation: Tasks — Property: Name — Calculate: Count all
Rollup 2: name "Completed Tasks" — Relation: Tasks — Property: Status — Calculate: Count values where Status = Done

Add a Formula property — name it "Progress"

The formula:

if(Total Tasks > 0 and Completed Tasks == Total Tasks, "100%",
if(Status == "backlog" or Status == "on hold", "0%",
if(Total Tasks > 0,
  let(
    completed_val, if(empty(Completed Tasks), 0, toNumber(Completed Tasks)),
    total_val, if(empty(Total Tasks), 0, toNumber(Total Tasks)),
    percentage, round(completed_val / total_val * 100),
    progress_blocks_count, floor(percentage / 10),
    filled_bar, (substring("", 0, progress_blocks_count)),
    empty_bar, (substring("", 0, 10 - progress_blocks_count)),
    format(percentage) + "% " + filled_bar + empty_bar
  ),
"0%")))

What each part does:
if(Total Tasks > 0 and Completed Tasks == Total Tasks, "100%", — the first check handles the fully complete case cleanly. If every task is done, return "100%" immediately without running the rest of the calculation.
if(Status == "backlog" or Status == "on hold", "0%", — projects in Backlog or On Hold return "0%" regardless of their task count. A project you're not working on yet shouldn't show partial progress even if it has tasks attached.
if(Total Tasks > 0, — only run the calculation if tasks actually exist. This prevents division-by-zero errors on new projects with no tasks linked yet.
let( — opens a local variable scope. Everything inside let() is calculated once and reused, keeping the formula readable rather than repeating the same expressions multiple times.
completed_val, if(empty(Completed Tasks), 0, toNumber(Completed Tasks)), — converts the Completed Tasks rollup to a number, defaulting to 0 if the rollup is empty.
total_val, if(empty(Total Tasks), 0, toNumber(Total Tasks)), — same conversion for Total Tasks.
percentage, round(completed_val / total_val * 100), — divides completed by total, multiplies by 100, rounds to the nearest whole number.
progress_blocks_count, floor(percentage / 10), — converts the percentage to a 0–10 scale for the visual bar. 70% becomes 7 filled blocks.
filled_bar, (substring("", 0, progress_blocks_count)), — builds the filled portion of the visual bar using a repeated character, sliced to the right length.
empty_bar, (substring("", 0, 10 - progress_blocks_count)), — builds the empty portion of the bar for the remaining blocks.
format(percentage) + "% " + filled_bar + empty_bar — concatenates the percentage number with the visual bar into a single readable output like 70% ███████░░░
"0%"))) — the fallback for any project with no tasks attached.

The result: A single property that shows both the precise percentage and a visual bar — 70% ███████░░░ — updating automatically as tasks are completed. Projects in Backlog or On Hold always show 0% cleanly, and fully completed projects snap to 100% without rounding errors.

One thing to watch: The Status check in the second line references your project's Status property directly — make sure your Status options are named exactly "backlog" and "on hold" (lowercase) or update the formula strings to match your exact option names. The comparison is case-sensitive.

Formula 2: Automatic Task Value Calculation

What it does: Assigns a point value to each task automatically based on its priority — so the value is set the moment you choose a priority, with no separate field to fill in.

Why it matters: If you're using a gamified productivity system — or building toward one — manual value entry creates friction at exactly the wrong moment. You've just decided to add a task. The last thing you want to do is also decide how many points it's worth. This formula makes the value decision automatic: High priority tasks give more points, Low priority tasks give fewer, and you only have to set the priority — which you'd be doing anyway.

Where to use it: In a Tasks database with a Priority select property.

Setup:

In your Tasks database, confirm you have a Select property called "Priority" with options: Low, Medium, High
Add a Formula property — name it "Task Value"

The formula:

if(Priority == "High", 10, if(Priority == "Medium", 5, 1))

What each part does:

if(Priority == "High", 10, — if priority is High, the task is worth 10 points.

if(Priority == "Medium", 5, — Medium priority tasks earn 5 points.

1)) — everything else — Low priority or unset priority — earns 1 point. Two closing parentheses for two nested ifs. Low priority tasks still get 1 point rather than 0, which means every completed task contributes something regardless of how it was prioritized.

The result: Every task automatically has a value the moment you set its priority. No separate field to fill in, no decisions to make. High = 10, Medium = 5, Low = 1.

Rolling Task Value up to your Character Sheet: Once tasks have values, create a Rollup in your Character Sheet database:

Relation: Tasks
Property: Task Value
Filter: Status = Done
Calculate: Sum

This gives you a running total of points earned from completed tasks only — the foundation of the leveling system. Every time you complete a task, the rollup updates automatically and your total climbs.

One thing to watch: The formula checks the exact string value of your Priority options. If your options are named "HIGH" or "high" or "High Priority" instead of "High," the formula won't match. Open your Priority property settings, check the exact option names, and update the formula strings to match.

Using Both Together

These formulas work independently — you can add either one to an existing workspace without touching the other. But they're designed to complement each other.

The progress formula tells you where your projects stand. The task value formula rewards you for completing the work that moves them forward. Together they create a feedback loop: you can see the project moving (progress %), and each completion registers as a real gain (task value rolling up to your total).

That loop — visibility and reward — is what most productivity systems are missing. The checkboxes are there. The motivation to check them isn't.

If you want both of these formulas pre-configured in a workspace that's already set up and linked together, that's what DevHub Basic gives you. The free version has the full database structure with these formulas already in place.

If you'd rather build it yourself, copy the formulas above directly — they're ready to paste into your formula editor.

I Tracked My Productivity for 90 Days Before and After Gamification. Here's What the Data Shows.

Lux Seminare — Sat, 30 May 2026 07:31:41 +0000

I want to be upfront about something before you read this.

I'm not a developer. I build Notion productivity systems for developers. So when I say I tracked my productivity, I mean I tracked my own workflow as someone who manages multiple products, handles customer feedback, writes content, and does a lot of the administrative work that comes with running a small digital product business.

The tasks are different from coding. The principle turned out to be the same.

Here's what I measured, what changed, and what stayed exactly the same.

The Setup

For 45 days I used a traditional Notion setup. Plain task database, status column, due dates. Nothing fancy. I logged every task I completed, what type it was, and how long it took.
Then I switched to a gamified system — the same one I eventually packaged into DevHub — and tracked the same metrics for another 45 days.

Same categories. Same logging discipline. Same types of work. The only variable was the system.

I tracked four things:

Tasks completed per week
Learning hours per week
How many days per week I actually opened my task manager
Subjective motivation score at end of each day (1–10, logged in a daily note)

I did not track revenue, output quality, or anything that could be attributed to a dozen other variables. Just the task behavior itself.

Before: 45 Days with a Traditional System

Average tasks completed per week: 15

Some weeks were higher — 19 or 20 when I had a clear deadline pushing me. Some were much lower — 9 or 10 on weeks where nothing felt urgent.

The pattern I noticed: I completed tasks when external pressure demanded it, not because the system motivated me. The system was neutral at best.

Average learning hours per week: 2.1

I had a running list of things I wanted to learn. It sat there. I'd open it occasionally, feel vaguely guilty about not making progress, close it. The learning tasks never felt urgent enough to prioritize over the task list proper.

*Days per week I opened my task manager: 3.8 out of 7
*
This one surprised me when I calculated it. I was avoiding my own system almost half the week. On those days I worked from memory and Slack notifications, which meant I was reactive rather than intentional about what I worked on.

Average daily motivation score: 5.9 out of 10

Not miserable. Not energized. Somewhere in the middle, most days feeling like I was keeping up rather than making progress.
The feeling I kept writing in my notes: I'm doing work but I can't tell if it's the right work, and I can't tell if I'm getting better.

What I Changed

I rebuilt my Notion workspace using game design principles. The structural changes were:

Tasks now earned XP on completion. The amount varied by a priority property — high priority tasks gave a small bonus on top of the base value.

Projects showed completion percentage that fed directly into XP. So finishing a project felt like finishing a quest — there was a visible endpoint and a reward attached to reaching it.

Learning was no longer a separate list that I ignored. It lived in the same workspace as my tasks, linked to the projects that needed it, and contributed XP when I made progress on it. This made learning feel like part of the work rather than optional enrichment.

A character sheet showed my current level, total XP, tasks completed, and a streak counter. I looked at it every morning before starting work.

That last part turned out to matter more than I expected.

After: 45 Days with a Gamified System

*Average tasks completed per week: 26
*
That is a 73% increase from 15 to 26.

I want to be careful about how I frame this. The tasks I was completing were not necessarily more important than before. I did not suddenly become a different person. What changed is that I had a reason to complete tasks that existed independent of external deadlines.

Before, I completed tasks when something forced me to. After, I completed tasks because each one moved a visible number upward. That sounds trivial. In practice it was not.

*Average learning hours per week: 4.7
*
A 124% increase. This one I attribute almost entirely to one structural change: learning was now in the same workspace as my tasks and contributed to the same XP total. It stopped being a separate category I could deprioritize. It became just another type of work with the same reward structure.

The weeks where I did the most learning were not the weeks where I felt most motivated. They were the weeks where I had the most active projects — because each project had learning tasks linked to it, so doing the project work surfaced the learning naturally.

Days per week I opened my task manager: 6.4 out of 7

From 3.8 to 6.4. I went from avoiding my system almost half the week to opening it almost every day.

This is the metric I find most significant. The task completion increase is partly a consequence of this one — you can't complete tasks in a system you don't open. The gamification didn't make me more disciplined. It made the act of opening the system feel like something other than confronting a list of failures.

Average daily motivation score: 7.4 out of 10

From 5.9 to 7.4. The feeling I kept writing in my notes after the switch: I can see what I did today. I can see I'm slightly better than I was last week.

What Gamification Did Not Change

Task quality. I did not produce better work because of XP. If anything, there were weeks where I noticed myself gravitating toward easier tasks because they were still tasks and still gave XP. I had to consciously counteract this by making sure high-priority tasks had appropriately weighted values.

Clarity about what to work on. The gamification layer does not make decisions for you. On days where I wasn't sure what the right next thing was, the XP system did not help. I still needed a clear priority structure — the gamification just made it more rewarding to execute on it once I had it.

Deep work capacity. I don't think I got meaningfully better at sustained focused work because of gamification. What I got better at was showing up to the workspace consistently, which created more opportunities for deep work — but the deep work itself still required everything it always required: time, silence, no notifications, a clear problem.

Discipline on hard days. Some days I still didn't want to work. The character sheet didn't fix that. The days where motivation was genuinely low, the XP system felt like a thin layer over a real problem that needed a real solution — rest, exercise, a conversation with someone, not more dopamine from a number going up.

Why I Think the Numbers Moved

My honest interpretation: the gamification didn't make me more capable. It removed specific friction points that were causing avoidance.

The three friction points it removed:

Invisible progress. Before, completing tasks made them disappear. There was no accumulating record of what I'd done. Each week started from zero. The XP system gave completion a visible, permanent effect — the number only goes up, and you can see how far it's come.
Learning deprioritization. Before, learning lived in a separate list that had no connection to my project work and no reward for making progress. After, it was structurally integrated and mechanically equivalent to any other task. Integration changed behavior more than motivation ever did.
System avoidance. Before, opening my task manager meant confronting everything I hadn't done. After, opening it meant seeing my level, my streak, my recent XP gains. The first thing I saw was evidence of progress rather than evidence of backlog. That sounds like a small thing. It is not a small thing.

What This Means If You're Considering a Gamified System

It will probably help if your main problem is one of these three: you avoid opening your task manager, you deprioritize learning consistently, or you feel like you're doing work but can't see yourself improving.

It probably won't help if your main problem is clarity — knowing what to work on, prioritizing correctly, managing a complex project with many dependencies. A gamified system is motivational infrastructure, not decision-making infrastructure. You still need to think clearly about what matters. The XP just makes it more rewarding to execute once you've decided.

The other thing worth saying: the 73% number is real but it's also mine. Your baseline matters. If you're already completing 40 tasks a week because external structure forces you to, gamification might add less. If you're completing 8 tasks a week because you avoid your system entirely, it might add more.

The free version of DevHub gives you the structural foundation — the databases, the views, the linked system — without the XP layer. If you want to test whether the structure alone changes anything before committing to the full gamified version, that's the right place to start.

→ luxseminare.gumroad.com

How to Build Learning Tracker in Notion

Lux Seminare — Fri, 29 May 2026 13:39:56 +0000

How to Build a Learning Tracker in Notion That Actually Teaches You Things

Most Notion learning trackers are glorified course lists.

You add a course, set the status to In Progress, update the progress percentage occasionally, and call it a system. The problem is that tracking progress through a course is not the same as retaining what the course teaches. You can watch every video, mark it complete, and remember almost nothing three weeks later.

This guide builds something more complete. Not just a tracker for what you're learning, but a system for how you learn — with spaced repetition scheduling that tells you when to review something, active recall templates that force retrieval rather than passive re-reading, and a dashboard that surfaces the right material at the right moment without you having to think about what to study next.

It's more involved than a simple database. It's also significantly more useful.

What You're Building
Three interconnected databases:

Skills & Topics Hub — the subjects you're developing, with visual progress tracking
Resource Library — the courses, books, articles, and documentation feeding into those skills
Notes & Synthesis Log — your active recall notes with automatic spaced repetition scheduling

A dashboard pulling all three together into one workspace with filtered views for capturing, studying, and reviewing.

Step 1: Base Page Setup

Create a blank page in Notion and name it Learning Tracker.
At the top, type /callout to insert a callout block. Add the icon ✦ and label it Learning Tracker Controller. This serves as your workspace header — a fixed reference point at the top of the page.

Press Enter and type three dashes --- to insert a thin divider beneath the header.

Below the divider, you'll set up a two-column layout. Type two lines of placeholder text: "Left Column" and "Right Column." Hover over "Left Column," click and hold its six-dot drag handle, and drag it to the left edge of "Right Column" until a vertical blue guide line appears. Release. This creates a 30% / 70% split — the left column for navigation and capture, the right column for your main working views.

Leave the placeholder text for now. You'll replace it with linked database views in Step 7.

Step 2: Create Your Database Directory

Before building the databases, create a hidden directory page to store the source databases. Below the column layout, type /heading 1. Type "Database Directory". Below it, create three separate databases using /table → Table view → New database:

Skills & Topics Hub
Resource Library
Notes & Synthesis Log

Step 3: Configure Database Properties

Navigate into each database inside the Database Directory and set up the properties exactly as listed.

Skills & Topics Hub

Properties You Need:

Title (Default)
Status (Select)

Status Options (You can customize):

Not Started
In Progress
Mastered

The Progress Bar property comes later via formula — don't add it manually.

Resource Library

Properties You Need:

Status (Status)
Type (Select)
URL (URL)

Status Options (You can customize):

To Start (Not Started Category)
In Progess (In Progress Category)
Completed (Complete Category)

Type Options (You can customize):

Video
Article
Book
Course
Documentation

Use Notion's native Status property type (not Select) for the Status column — it has built-in category groupings that the formula and filtering logic depends on.

Notes & Synthesis Log

Properties You Need:

Title (Default)
Last Reviewed (Date)
Retention Score (Select)

Retention Score Options (You can customize):

Again
Hard
Good
Easy

The Title field naming convention matters here. Every entry in Notes & Synthesis Log should be phrased as a question you'd ask yourself during review — not "React useEffect" but "What does useEffect do and when does it run?" This framing turns passive browsing into active retrieval every time you open the database.

Step 4: Build the Bi-Directional Relations

Relations connect the three databases so that a skill knows which resources feed into it, which notes synthesize it, and a resource knows which notes were taken from it. Build them in this order.

In Skills & Topics Hub:

Add a Relation property → search for Resource Library → toggle on "Show on Resource Library."

Name in Skills & Topics Hub: Resources
Name in Resource Library: Skill / Topic

Add a second Relation property → search for Notes & Synthesis Log → toggle on "Show on Notes & Synthesis Log."

Name in Skills & Topics Hub: Notes
Name in Notes & Synthesis Log: Skill / Topic

In Resource Library:

Add a Relation property → search for Notes & Synthesis Log → toggle on "Show on Notes & Synthesis Log."

Name in Resource Library: Notes & Logs
Name in Notes & Synthesis Log: Resource Link

When complete, each database entry is connected across all three:

A skill → knows its resources and its notes
A resource → knows its skill and its notes
A note → knows its skill and its resource

This three-way connection is what makes the system function as a knowledge graph rather than three separate lists.

Step 5: Add the Formulas

Two formulas power the system's intelligence. Both use Notion Formulas 2.0 syntax.

Formula 1: Progress Bar in Skills & Topics Hub

This formula calculates what percentage of a skill's linked resources are completed and displays it as a color-coded visual bar without requiring any rollup properties.

Add a Formula property to Skills & Topics Hub. Name it Progress Bar. Open the formula editor and paste:

lets(
resources, prop("Resources"),
totalCount, resources.length(),

totalValue, resources.map(
if(current.prop("Status") == "Completed", 1,
if(current.prop("Status") == "In progress", 0.5, 0))
).sum(),

ratio, if(totalCount > 0, totalValue / totalCount, 0),

filledSegments, round(ratio * 10),
emptySegments, 10 - filledSegments,
progressBar, "■".repeat(filledSegments).style("purple", "b") + "□".repeat(emptySegments).style("gray"),

if(
totalCount > 0,
progressBar + " " + round(ratio * 100) + "%",
"No Resources Linked".style("gray", "i")
)
)

Formula 2: Next Review Date in Notes & Synthesis Log'

This formula implements spaced repetition scheduling. Based on your last Retention Score, it calculates when you should next review a note — automatically.

Add a Formula property to Notes & Synthesis Log. Name it Next Review Date. Open the formula editor and paste:

lets(
last, prop("Last Reviewed"),
score, prop("Retention Score"),
base, if(empty(last), now(), last),
interval,
if(empty(score), 0,
if(score == "Again", 0,
if(score == "Hard", 1,
if(score == "Good", 3,
if(score == "Easy", 7,
0))))),
dateAdd(base, interval, "days")
)

How to use it:

After reviewing a note, update Last Reviewed to today and set Retention Score to how well you remembered it. The Next Review Date recalculates automatically. Notes you rated Easy disappear from your review queue for a week. Notes you rated Again reappear immediately.

This is a simplified spaced repetition system — not as sophisticated as Anki's algorithm, but significantly more effective than reviewing everything at random or reviewing nothing at all.

Step 6: Create the Active Recall Template

Active recall is the practice of retrieving information from memory rather than passively re-reading it. The template enforces this by hiding answers inside toggle blocks — you read the question, attempt the answer mentally, then reveal the answer to check.

In Notes & Synthesis Log, click the dropdown arrow next to the blue New button → select + New Template → name it ✦ Active Recall Note.

Inside the template canvas, build this structure:

Line 1: Type /toggle to create a toggle block. Title it: Click to Reveal Core Concept Answer

Inside the toggle (click to open it), write the answer, explanation, or synthesis. For code-related notes, type /code to insert a code block with syntax highlighting. For inline references, wrap terms in backticks.

The answer lives inside the toggle. When you review the note, you read the title (the question), attempt recall, then click the toggle to verify. This is the retrieval practice that makes the learning stick.

Line 2: Below the toggle, type --- for a divider.

Line 3: Type ## Synthesis Log as a Heading 2.

Under the Synthesis Log heading, write a plain-language explanation of the concept in your own words. Not a copy of the source material — your own synthesis. If you can't explain it in your own words, you don't understand it yet. This section exposes that gap before you move on.

Click back to exit the template editor. Now every new note created in Notes & Synthesis Log can use this template with one click.

Step 7: Assemble the Dashboard

Return to your top-level Learning Tracker page. Delete the placeholder column text and replace it with linked database views.

Left Column (30% width) — Navigation and Capture

View 1: Quick Inbox Capture

Type /list → select List view → choose Notes & Synthesis Log as the data source.

Add two filters:

Resource Link → is empty
Skill / Topic → is empty

This view shows only notes that haven't been linked to a skill or resource yet. Use it as a capture inbox — write notes quickly here without worrying about categorization, then triage them into the right skill and resource later.

View 2: Skills & Taxonomy Roadmap

Type /board → select Board view → choose Skills & Topics Hub as the data source → group by Status.

Click the three dots on the database block → Properties → click the eye icon to make Progress Bar visible on the cards.

The board shows your skills organized by Not Started, In Progress, and Mastered, with each card displaying its visual progress bar. At a glance you can see which skills are active and how far along each one's resource list is.

Right Column (70% width) — Active Work

View 3: Active Research Feed

Type /gallery → select Gallery view → choose Resource Library as the data source.

In layout options: set Card preview to None, card size to Small.

Add a filter: Status is In Progress.

Show properties: Type and Skill / Topic.

This view shows only the resources you're currently working through — nothing queued, nothing completed. A small gallery of active items gives you a clear read on whether you have too many resources open at once (more than three usually means context switching is happening).

View 4: Today's Active Recall Queue

Type /board → select Board view → choose Notes & Synthesis Log as the data source.

Add a filter: Next Review Date is on or before Today.

Group by: Retention Score. Sort ascending by Next Review Date.
This is your daily study queue. Every note whose Next Review Date has arrived appears here automatically. The Retention Score grouping shows which notes keep returning as Again or Hard — those are the concepts that need more attention. Notes rated Easy move to a 7-day interval and disappear from the queue until next week.

Open the board each morning. Work through the cards. Update Last Reviewed and Retention Score for each one. The queue rebuilds itself overnight based on the scores you set.

Step 8: Connect to Notion Calendar

Notion Calendar lets you see your review schedule as actual calendar events — useful for planning study sessions alongside your regular work.

Open Notion Calendar (calendar.notion.so or the desktop app).
Go to Settings → Notion workspaces → Add Notion workspace to authenticate.

In the left sidebar, hover over your workspace name → click ••• → select Add Notion database.

Search for and select Notes & Synthesis Log.

How the System Works Day to Day

When you start a new resource:

Add it to Resource Library with Status = To Start. Link it to the relevant skill in Skills & Topics Hub. The skill's Progress Bar stays at 0% until you start completing resources.

While working through the resource:

Change Status to In Progress. Take notes in Notes & Synthesis Log using the Active Recall template. Phrase every note title as a question. Link each note to both the resource and the skill.

After a study session:

Open Today's Active Recall Queue. Review each due note — read the question, recall the answer, click the toggle to verify. Update Last Reviewed to today. Set Retention Score honestly. The Next Review Date recalculates.

When a resource is complete:

Change Status to Completed. The Progress Bar in Skills & Topics Hub updates automatically. When all resources for a skill are complete, the bar fills. Change the skill Status to Mastered.

Weekly:

Check Quick Inbox Capture for unlinked notes and triage them. Check the Skills Roadmap for skills that have stalled. Open Active Research Feed and confirm you don't have more than three resources In Progress simultaneously.

Why This Works Better Than a Simple Progress Tracker

The standard learning tracker tells you how far through a course you are. This system tells you how much of what you've covered you actually remember.

The spaced repetition schedule means concepts you struggle with come back sooner. Concepts you know well come back less often. Over time the review queue adapts to the shape of your actual knowledge gaps rather than reviewing everything at a fixed interval.

The active recall templates mean every review session is a retrieval practice event, not a re-reading session. Retrieval practice produces significantly better long-term retention than passive review. The toggle structure enforces it without requiring willpower.

The relational architecture means your skills, resources, and notes are never disconnected. A skill knows its resources. A note knows where it came from. Nothing lives in isolation.

If you want a pre-built version of this system without building all the formulas and relations from scratch, click here.

What's your current system for retaining what you learn from courses? Drop it in the comments.

10 Notion Productivity Systems Compared (2026 Guide)

Lux Seminare — Tue, 26 May 2026 06:17:13 +0000

I've tried most of these. Some stuck. Most didn't. Here's what actually separates them.
This isn't a ranking. Different systems solve different problems, and the one that works for you depends on what's actually breaking in your current workflow. Read the problem description for each one first — if it doesn't sound like your problem, the system probably isn't for you.

1. GTD — Getting Things Done
The problem it solves: You have commitments everywhere — email, Slack, sticky notes, your head — and no single place that holds all of them. You spend mental energy remembering things instead of doing them.
Core idea: Capture everything into one trusted system. Process it into actionable next steps. Review it regularly. Your brain is for thinking, not storage.
How it works in Notion:
Build four databases: Inbox (raw capture), Projects (multi-step outcomes), Next Actions (single physical tasks), and Reference (non-actionable information). Everything you capture goes to Inbox first. During your daily review you process each item into one of the other three. Nothing stays in your head.
What it's genuinely good at: Handling complexity. If you're juggling 10+ projects across multiple life areas — work, side projects, family, health — GTD scales better than anything else on this list because it has explicit rules for every type of input.
Where it breaks down: The setup is involved, and the weekly review is non-negotiable. Skip it for two weeks and the whole system becomes untrusted. Most people find the processing step (deciding what something is and where it goes) more friction than they expected.
Best for: Senior developers, consultants, or anyone whose job involves managing a lot of incoming requests across multiple contexts simultaneously.

2. PARA Method
The problem it solves: You have information everywhere and can't find anything when you need it. Your notes, projects, and resources all blend together.
Core idea: Organize everything into four categories — Projects (active, deadline-driven), Areas (ongoing responsibilities), Resources (reference material by topic), Archives (inactive stuff). The key insight: information should be organized by how actionable it is, not by what topic it belongs to.
How it works in Notion:
Four top-level pages: Projects, Areas, Resources, Archives. Every note, document, and database lives inside one of these. Projects have a clear end state and a deadline. Areas are ongoing (health, finances, career). Resources are topics you're interested in. Archives is everything else you want to keep.
What it's genuinely good at: Organizing reference material. If you take a lot of notes, save a lot of articles, and do a lot of research, PARA gives you a filing system that actually makes sense at retrieval time.
Where it breaks down: PARA is an organizational system, not a task management system. It tells you where to put things, not what to work on next. Most people combine it with GTD or a simpler daily task method.
Best for: Knowledge workers, researchers, writers, and developers who do a lot of note-taking and need their reference material organized.

3. Bullet Journal Method (BuJo)
The problem it solves: Digital systems feel overengineered. You open your task manager and spend more time organizing tasks than doing them.
Core idea: A simple analog-inspired logging system using rapid logging — short, coded entries (tasks, events, notes) in a running log. Daily log, monthly log, future log. Migrate unfinished tasks forward or drop them if they no longer matter.
How it works in Notion:
Create a Daily Log database with date, entry type (task/event/note), content, and status. Add a Monthly Log page as a simple calendar view. Add a Future Log page for things more than a month out. Use simple symbols: • for task, ○ for event, — for note, × for completed, > for migrated.
What it's genuinely good at: Forcing prioritization. The migration process (rewriting unfinished tasks each day) is intentionally tedious — it makes you ask whether the task is actually worth carrying forward. Things that aren't important naturally drop off.
Where it breaks down: Notion isn't a great fit for BuJo's rapid, freeform nature. The original is analog for a reason. The digital version loses a lot of the feel. It also doesn't scale well to complex projects.
Best for: Developers who are overwhelmed by complex systems and want something minimal that forces them to prioritize daily.

4. Zettelkasten
The problem it solves: You read and learn constantly but none of it connects. Your notes are a graveyard of things you've forgotten.
Core idea: Every note is atomic (one idea only), written in your own words, and linked to related notes. Over time the links between notes create an emergent knowledge graph — ideas connect in ways you didn't anticipate when you wrote them.
How it works in Notion:
One database for all notes. Each note has a unique ID, a title, the content (in your own words, never copy-paste), and a relations field linking to other notes. Add a "Source" field for where the idea came from. Browse using the graph or by following links from one note to another.
What it's genuinely good at: Long-term knowledge development. If you're doing deep learning — reading books, papers, building expertise over years — Zettelkasten makes old knowledge findable and combinable in new ways.
Where it breaks down: High upfront cost per note. Writing everything in your own words and linking it properly takes time. It rewards patience. Most people give up before the network is dense enough to feel useful.
Best for: Developers who write, research, or want to build deep expertise in a technical domain over years.

5. Time Blocking
The problem it solves: Your calendar is full of meetings but your actual work — the deep, focused kind — never gets scheduled. It gets squeezed into whatever gaps are left.
Core idea: Treat your time like a budget. Every hour of your workday is assigned to a specific type of work in advance. Deep work blocks are protected, not optional.
How it works in Notion:
A simple weekly template with time blocks as rows and days as columns. Color-code by block type: deep work (green), meetings (red), admin (yellow), buffer (gray). Each morning, fill in what you'll actually do in the deep work blocks. Review at end of day — did reality match the plan?
What it's genuinely good at: Protecting maker time. For developers, uninterrupted blocks are the only time meaningful work gets done. Time blocking makes those blocks explicit and defensible.
Where it breaks down: Requires a calendar that you actually control. If your day is dominated by meetings you can't move, time blocking helps less. Also breaks down badly when things run over — the rest of the day cascades.
Best for: Developers with some control over their schedule who want to protect their deep work time.

6. Kanban
The problem it solves: You have too much in progress at once. You're working on six things simultaneously and finishing none of them. Work piles up in columns nobody reviews, and there's no shared language for what "in progress" actually means.
Core idea: Visualize the entire flow of work — not just tasks, but the stages they move through. Limit work in progress at every stage, not just the doing column. When something is blocked, the block is visible to everyone immediately. The system pulls work forward based on capacity rather than pushing it in based on demand.
How it works in Notion:
A Board view of your Tasks database. Columns represent stages in your actual workflow — not just Backlog, Doing, Done, but the real stages your work moves through: Backlog, Defined, In Progress, In Review, Done. Each column has an explicit WIP limit you set and respect. Cards show the information that matters at each stage — assignee, priority, due date, blocker flag. You can add a Blocked status that surfaces stuck work immediately rather than hiding it inside a column where it looks like progress.
What it's genuinely good at: Making flow problems visible. Kanban doesn't just show what you're working on — it shows where work slows down, stacks up, or stops moving. A column with 8 cards in it when the WIP limit is 3 tells you exactly where your bottleneck is. You can't ignore it because it's right there on the board.
Where it breaks down: Kanban requires consistent discipline around WIP limits and column definitions. If everyone adds cards freely and WIP limits become suggestions, the board degrades into a visual task list with no actual flow control. It also requires honest column definitions — if "In Review" means different things to different people, the board lies.
Best for: Developers working on teams or managing multi-stage workflows where the bottleneck isn't the work itself but the movement of work between stages. Also effective for solo developers who notice they start many things and complete few of them.

7. OKRs (Objectives and Key Results)
The problem it solves: You're productive on a day-to-day basis but you're not sure if the work you're doing is moving toward anything meaningful. Busy but not purposeful.
Core idea: Set a small number of ambitious Objectives (qualitative, inspiring). Under each, define 3–4 Key Results (measurable outcomes, not tasks). Review quarterly. The task list serves the OKRs — not the other way around.
How it works in Notion:
An Objectives database with a rollup to a Key Results database. Each Key Result has a target value, a current value, and a progress percentage. Link tasks from your task database to Key Results so you can see which work is contributing to which outcome.
What it's genuinely good at: Alignment. If you're working on side projects or building a product, OKRs force you to be explicit about what success looks like before you start working.
Where it breaks down: Overkill for day-to-day personal task management. The overhead of maintaining OKR tracking is only worth it if the work is complex enough to drift from its goals without explicit measurement.
Best for: Indie developers, founders, or anyone running a project with multiple contributors and a need to stay aligned on direction.

8. The One Thing Method
The problem it solves: Priority lists of 10 items aren't priorities. Everything feels equally important and you make slow progress on all of it.
Core idea: Every day, identify the single most important thing you could do — the thing that, if done, would make everything else easier or unnecessary. Do that first. Everything else is secondary.
How it works in Notion:
The system is intentionally minimal. A simple daily page with one field: "The One Thing today is ___." Below it, your regular task list. The One Thing gets done before you open email, Slack, or anything reactive.
What it's genuinely good at: Cutting through noise. If you're prone to busywork — clearing low-value tasks to feel productive — forcing yourself to name one high-leverage thing each morning is a direct countermeasure.
Where it breaks down: Doesn't scale to complex project management. Works best as a daily ritual layered on top of another system, not as a standalone approach.
Best for: Developers who know what their high-leverage work is but consistently deprioritize it in favor of easier tasks.

9. Full Life OS / Second Brain
The problem it solves: Your life has too many dimensions — work, health, finances, relationships, learning, side projects — and they each live in different places. There's no single place to see the whole picture.
Core idea: Build a unified personal operating system in Notion that tracks everything. One workspace, all areas of life, all databases linked. The goal is complete externalization of your mind into a trusted, searchable, connected system.
How it works in Notion:
A home dashboard with quick links to every area. Separate databases for: work tasks, personal tasks, goals, habits, finances, health metrics, relationships, projects, notes, learning, journal. Everything linked. Rollups showing cross-database statistics on the home page.
What it's genuinely good at: Completeness. If you want one place for everything and you're willing to invest in building and maintaining it, a Life OS eliminates the problem of fragmented information across apps.
Where it breaks down: The maintenance burden is real. A Life OS only works if you actually update it daily. It's also easy to spend more time building the system than using it — especially in Notion, where building is enjoyable and feels productive.
Best for: Developers who want full coverage and are disciplined enough to maintain a complex system consistently.

10. DevHub — Gamified Developer System

The problem it solves: You've tried most of the systems above. They work for a week, then you stop opening them. The work doesn't change — but your motivation to track it does. Traditional productivity systems provide no positive reinforcement for doing the work they're supposed to help you do.
Core idea: Apply game design psychology to developer workflows. Tasks earn XP. Projects are quest lines. Bugs are Glitch Purges. Learning is a skill tree. Your character sheet tracks your growth as a developer over time. The system makes progress visible and rewarding in a way checkboxes never can.
How it works in Notion:
Six interconnected databases: Tasks, Projects, Learning Paths, Docs, Bug Tracker, Character Sheet. Tasks link to projects. Learning links to projects (so you can see why you're learning something). Bugs link to tasks. Everything rolls up to a character sheet showing total XP, current level, quests completed, glitches purged, learning hours, and streak.
What it's genuinely good at: Retention. Most productivity systems fail not because they're poorly designed but because they're not motivating enough to use consistently. The gamification layer solves the motivation problem without changing the underlying work structure.
Where it breaks down: Not for everyone. If you find the RPG framing gimmicky rather than motivating, this will feel like friction. The system also requires some upfront setup to get the databases connected correctly.
Best for: Developers, engineers, and technical creators who know what they should be doing but struggle to maintain consistent productivity system usage over weeks and months.

Which one should you actually use?
The answer depends on which problem statement hit closest to home when you read through the list above.
If your problem is too much incoming work across too many projects: **GTD or PARA.
If your problem is **work moves slowly through your pipeline and you can't see why: Kanban.
If your problem is you're productive but not purposeful: OKRs or The One Thing.
If your problem is you take lots of notes but can't find them: Zettelkasten.
If your problem is every system you try lasts two weeks: DevHub.
The worst thing you can do is pick the most complex system and try to set it up perfectly before using it. Pick the one that matches your actual problem, use it for 30 days in its simplest possible form, then decide what to add.
A free version of DevHub is available if you want to try a pre-built version of system 10 without setting up the databases yourself.

What system are you using right now? Drop a comment — genuinely curious what's working and what isn't.

I Disappeared for 4 Months After Launch - Here's What Brought Me Back

Lux Seminare — Mon, 25 May 2026 07:06:24 +0000

The Launch

July 2025: I spent months building DevHub, a gamified Notion system for developers.

Launch day expectations:

100+ sales first week
Viral Reddit post
Product Hunt success

Reality:

18 views on launch day
2 sales total
Crickets on Product Hunt

Then I vanished for 4 months.

Why I Disappeared

Not because I gave up on the product.

Because I had absolutely zero idea what to do next.

I'd done everything "right":
✅ Built a good product
✅ Posted on Reddit
✅ Launched on Product Hunt
✅ Made it available

And... nothing happened.

The mistake:

I treated marketing like a one-time event, not a daily practice.

I thought: "Build it, launch it, people will come."

Nobody came.

The 4-Month Silence

During those months:

Didn't post
Didn't email users
Didn't engage anywhere
Just... stopped

Why?

Because every post felt like shouting into the void.

When you have zero audience:

Twitter posts get 1-3 views
Reddit posts get buried
Blog posts get zero traffic
Nothing moves

It's demoralizing.

So I stopped trying.

What Changed

Two things brought me back:

1. Real testimonials from my testers

I'd given 10 people free access in exchange for feedback.

Only 2 responded. But their feedback was gold:

"I adapted it for both work and school. The flexibility made it stick."

"I use the XP system to tie into real rewards."

Hearing that it ACTUALLY helped someone? That's validation.

2. Realizing I'd learned nothing

I failed at marketing, not building.

The product works. I just sucked at telling people about it.

But marketing is a learnable skill.

Giving up = I learn nothing
Trying again = I learn what works

What I Got Wrong

Looking back, my mistakes were obvious:

1. Built first, marketed never

Should have been:

Building audience while building product
Sharing progress on Twitter
Writing tutorials on Dev.to
Engaging in communities

Instead: Built in silence, launched to nobody.

2. Expected instant results

2 weeks of posting ≠ traction

Most successful products take 3-6 months of consistent marketing.

I quit after 2 weeks.

3. One platform only

Relied entirely on Reddit.

When those posts stopped performing, traffic died completely.

4. No email list

Had 70+ free downloads. Never emailed them once.

Just let them disappear.

5. Posted once, hoped for virality

One post → no traction → gave up

Should have been: Daily posting for 90+ days minimum.

What I'm Doing Differently

Starting today:

Daily content across platforms:

Twitter: Value-first posts (not pitching)
Dev.to: Tutorials and building in public
Reddit: Genuine engagement before promoting
LinkedIn: Professional angle
Email: Actually using the list I have

Building in public:

Sharing metrics (even when bad)
Sharing lessons learned
Being transparent about struggles

Multiple platforms:
Not relying on Reddit alone.

Patience:
Committing to 90 days of daily posting before judging results.

Email marketing:
Actually emailing my 140 free users.

Current Status

Metrics (being transparent):

3 paid sales ($13.35 total revenue)
140 free downloads
2 solid testimonials
~300 total page views

Not impressive. But honest.

For Other Builders

If you launched something and it flopped:

You're not alone.

Most launches are underwhelming.

Most products take months to gain traction.

Most of us suck at marketing.

The difference:

Some people keep going. Some disappear.

I disappeared for 4 months.

I'm back now.

Not promising success. Just promising honesty and consistency.

What's Next

Relaunching on Product Hunt next week.

This time with:
✅ Real testimonials
✅ Better positioning
✅ Actual marketing plan
✅ Realistic expectations

Will it work? No idea.

But trying beats hiding.

If you're building something:

Don't make my mistakes.

Start marketing before you launch.

Build audience + product in parallel.

Post consistently for 90 days minimum.

And don't disappear when it's hard.

That's when it matters most.

I build Notion productivity systems for developers. DevHub is my first real product launch. Learning as I go.

One Notion Trick That Actually Fixes Developer Overwhelm

Lux Seminare — Thu, 21 May 2026 12:01:24 +0000

You open your Notion workspace. There are 47 tasks staring at you.
Some are from last week. Some are from last month. Some are from a fever dream in February when you thought you'd learn Rust, containerize your side project, and document your entire API — all before dinner.
So you close Notion. Open VS Code. Work on whatever feels most urgent. Repeat tomorrow.
Sound familiar?
The problem isn't discipline. It's not a character flaw. It's that you're showing your brain too much at once.

Why "see everything" doesn't work

Most task managers default to showing you every single open task the moment you log in. The logic makes sense on paper: you want full visibility.
But your brain doesn't work that way.
Cognitive psychology research consistently shows that working memory handles roughly 4 things at a time — not 47. When you're confronted with a massive backlog, you don't get clarity. You get decision paralysis. And decision paralysis looks a lot like procrastination from the outside.
The backlog isn't motivating you. It's shutting you down.

The fix: a "Today" view

This is one of the simplest things you can do in Notion, and it changes how the whole workspace feels.
Instead of a view that shows every task, create a filtered view that shows only tasks due today.
That's it.
Here's how to set it up:

Open your Tasks database
Click + Add a view → select Table or List
Add a Date property then name it to "Due Date or Deadline"
Click Filter → Add filter → Due Date/Deadline → is → Today Save

Now make that view your homepage — the first thing you see when you open Notion in the morning.

What changes

When you open Notion and see 3 tasks instead of 47, something shifts.
Your brain doesn't shut down. It actually asks: okay, which of these do I start with?
That's a question you can answer.
You're not ignoring the other 44 tasks. They exist in your "All Tasks" view, which you can check during your weekly review. But on a Tuesday morning when you need to ship something, they're just noise.
The "Today" view gives you a daily container. A finite amount of work. An actual chance to feel done at the end of the day.

A few things to keep in mind

This only works if you actually set due dates on your tasks. If everything is undated, the filter returns nothing.
The habit: when you add a task, ask yourself when do I actually plan to do this? Then set that as the due date — not "someday," an actual day. It takes five seconds and makes the whole system work.
You can also build a "This Week" view with a filter for tasks due within 7 days, and use that for planning on Mondays.

The bigger picture

Clarity beats completeness when you're trying to get work done.
Seeing everything doesn't help you. Seeing the right thing at the right time does.
This is one of the core ideas behind how I built DevHub — a Notion productivity system for developers that structures your workspace around focus rather than completeness. The "Today" view is built in by default, alongside project tracking, learning paths, and a gamified XP system that makes it actually satisfying to close tasks.
Free version is available if you want to try the structure without committing.
But even if you never touch DevHub, add the "Today" view to whatever Notion setup you already have.
It's the smallest change with the biggest impact.

Have questions about setting it up? Drop a comment — happy to help.

How to Build a Gamified System in Notion (Step-by-Step)

Lux Seminare — Mon, 18 May 2026 20:08:17 +0000

How to Build a Gamified XP System in Notion (Step-by-Step)

Ever wanted your Notion workspace to feel more like an RPG? Where completing tasks gives you XP and you level up as you make progress?

I spent days building this part of my devhub system, so you don't have to. Here's how to create it from scratch.

What We’re Building

By the end of this tutorial, you'll have:

✅ Tasks that award XP when completed
✅ A character sheet showing your level
✅ A progress bar
✅ A Completion Badge

TIME TO BUILD: 30-45 minutes

The Concept

The basic flow:

Complete a task → Earn XP
XP accumulates → Level increases
Progress bar shows how close you are to completing the task
Completion Badge - your reward for finishing the task.

Simple, but effective for motivation.

Step 1: Create your Task Database

Create a new page in Notion. Give it a title.

Create a new database then name it Task. Table view works best.

Properties you need:
Title (Default)
Status (Select)

Priority (Select)

Assigned To (Person - Optional)

Progress (Formula)

Badge (Formula)

Task Value (Formula)

XP Earned (Formula)

User (Relation)

Is Done? (Formula)

Status Options (You can customize):

To Do
In Progress
Done
Blocked
Priority Options (You can customize):

Low
Medium
High
Progress Bar Formula (You can customize the progress bar):

if(

Status == "Done", "100% ██████████",
if(

Status == "In Progress", "50% █████",
if(

Status == "To Do", "0% ░░░░░░░░░░",
if(

Status == "Blocked", "Blocked",
"0% ░░░░░░░░░░"
))))

Badge Formula (You can customize the text and style):

if(Status == "Done", "🌟 Task Mastered!".style("c", "b", "green", "green_background"), "")

Task Value Formula (You can customize the XP value):

if(Priority == "High", 10, if(Priority == "Medium", 5, 1))

XP Earned Formula:

if(prop("Status") == "Done", prop("Task Value"), 0)

After you create your User Database, relate the User property to it.

Related to: User
Limit: No limit
Two-way Relation: On
Is Done Formula

prop("Status") == "Done"

Step 2: Create your User Database

Create another database then name it User. Set it up on table view first.

Properties you need:
Title (Default)
Tasks (Relation) (If you already created the User property on the Task Database, then skip this).
Tasks Completed (Rollup)

Tasks XP (Rollup)

Tasks Completion (Formula)

Click “New Page” on the database then put your name or anything under the title property (e.g. Lux Seminare).

Tasks Completed Rollup Setup

Relation: Task
Property: Is Done?
Calculate: Count → Checked
Tasks XP Rollup Setup

Relation: Task
Property: XP Earned
Calculate: More options → Sum
Tasks Completion Formula (Note: The levels are based from DevHub Pixel Forge Theme, feel free to customize it together with the XP goals.)

if(Task Completed >= 100, "Impact Driver ⚒️".style("", "red_background"), if(Task Completed >= 50, "Productivity Powerhouse 🦾".style("", "purple_background"), if(Task Completed >= 25, "Task Conqueror ⛳".style("", "blue_background"), if(Task Completed >= 10, "Task Initiator 🎲".style("", "brown_background"), if(Task Completed >= 5, "First Step 👣".style("", "gray_background"), "")))))

Step 3: Task Template

Go back to Task Database.
On the upper right side, click the blue drop-down button beside “New”.

Click “New Template”.

Click “New Page” then name it to something like “New Task”.

Click “User” then select your name.

Go back to Task Database again.
On the upper right side, click the blue-drop down button beside “New” again.

Click the three dots (…) beside “New Task” or whatever you’ve named the task template.

Select “Set as Default”.

Step 4: Make it Yours

Now that the "engine" of your XP system is running, it’s time to skin the game. This is where you transform a boring database into a dedicated RPG interface. You’ve got the logic; now give it some soul.

Upload your customized icons and covers.
The Character Sheet View
In your User Database, create a Gallery View.

Set the Card Preview to "Page Cover" and the Card Size to "Large."

Go to Properties and toggle on "Tasks Completion" and "Tasks XP."

This creates a visual player card that feels like an actual RPG character menu.
Create different views so you could have your own dashboard.

The goal here is to make the workspace so visually rewarding that you want to open it every morning. Experiment with Notion’s grouped views, sub-tasks, and tabbed databases until the flow feels natural to your specific dev workflow.

What’s Next?

To expand this, you could add:

Project tracking (quests with multiple tasks)

Bug Tracking System

All Docs Database

Learning Path Tracker

Habit Tracker

Daily Log Database

Achievements Page

I spent weeks building all of that into a complete system.

If you want the full thing, get it here. It comes with free version, with core databases but minus the gamification.

If you want to build it yourself: Use this tutorial as a starting point and customize however you want!

Happy to answer questions in the comments 👇

Why Gamification Actually Works for Developer Productivity (And Why I Was Wrong to Dismiss It)

Lux Seminare — Wed, 31 Dec 2025 10:32:51 +0000

I used to think gamifying productivity was gimmicky nonsense.

"Just give me a clean task list," I'd say. "I don't need points and badges to do my job."

Then I burned out.

Not the dramatic "I can't get out of bed" burnout. The subtle kind where you open your task manager, see 89 items, feel your soul leave your body, and close it immediately. Then you spend the day coding whatever feels urgent, constantly context-switching, never feeling like you're making real progress.

That was me in March 2025.

So I did something desperate: I rebuilt my entire productivity system as an RPG. Tasks became quests. Projects had XP rewards and difficulty ratings. I had a literal character sheet with a level and stats.

It felt ridiculous. I didn't tell anyone.

Full disclosure: I'm not a developer myself. But I built this system specifically for developers—people doing complex, creative work that requires deep focus and constant learning. The psychology applies to any knowledge work, but I designed the structure around the developer workflow because that's the audience I wanted to help.

But three months later, my task completion rate was up 73%. My learning consistency was up 160%. And for the first time in years, I actually wanted to open my task manager.

This article is about why gamification works, what the psychology research says, and how I went from skeptic to believer.

The Problem With Traditional Productivity Systems

Let's start with why traditional task managers fail for creative work.

Most productivity tools are designed around the factory model:

Here's your task

Do the task

Check the box

Move to the next task

Repeat forever

This works great for assembly-line work. It's terrible for knowledge work.

Here's why:

Problem #1: No Sense of Progress

When you complete a task, it just... disappears. The checkbox vanishes. Your list gets shorter. That's it.

There's no accumulation. No visible growth. Just an endless cycle of "here's more work."

Your brain interprets this as: "I'm not making progress. I'm just treading water."

Problem #2: Motivation Drainage

Opening a task manager that shows 47 unfinished items is emotionally exhausting.

Your brain doesn't see: "Look at all this potential progress!"

Your brain sees: "Look at all the things you HAVEN'T done. You're failing."

This is called negative framing, and it's demotivating by design.

Problem #3: No Feedback Loop

In most task managers, completing something gives you zero feedback beyond "task no longer visible."

No celebration. No acknowledgment. No dopamine hit.

Just silence, and then the next task appearing to fill the void.

For brains that run on reward circuits, this is brutal.

Problem #4: All Tasks Are Created Equal

A 15-minute bug fix and a 3-day feature build look identical in most task managers: a single checkbox.

Your brain can't distinguish effort. Can't see difficulty. Can't feel the weight of completing something hard.

Everything is just "done" or "not done."

Enter Gamification: The Accidental Solution

I didn't set out to "gamify productivity." I was just trying to make my task manager less soul-crushing.

Here's what I changed:

Instead of:

☐ Fix authentication bug
☐ Build user dashboard
☐ Learn TypeScript

I built:

🐛 Glitch Purge: Auth Vulnerability → 20 XP
🎯 Quest: User Dashboard Feature → 100 XP
📚 Learning Path: TypeScript Mastery → 100 XP

Same tasks. Completely different framing.

And something weird happened: I actually wanted to complete them.

Not because the work changed. But because my relationship to the work changed.

The Psychology: Why This Actually Works

After three months of using this system, I went back and researched why it was working. Turns out, there's solid psychology behind gamification.

Self-Determination Theory (SDT)

Developed by psychologists Edward Deci and Richard Ryan, SDT argues that humans need three things to stay intrinsically motivated:

Autonomy: Control over your work Mastery: Visible progress toward skill development Purpose: Understanding the bigger mission

Traditional task managers give you none of these.

Checkboxes don't show mastery. They don't connect to purpose. They barely acknowledge autonomy.

Gamification addresses all three:

Autonomy: You choose which quests to pursue

Mastery: XP and leveling show continuous growth

Purpose: Everything connects to a bigger narrative (your character's development)

The Progress Principle

Harvard professor Teresa Amabile studied what motivates knowledge workers. Her finding: "Of all the things that can boost emotions, motivation, and perceptions during a workday, the single most important is making progress in meaningful work."

The key word is "visible."

You need to see progress, not just experience it.

The problem with traditional task lists: Progress is invisible. Completed tasks disappear. Your brain has no record of growth.

The gamification fix: XP accumulates. Levels increase. Stats go up. Progress is impossible to ignore.

Even on days when you "only" completed 2 tasks, you can see: "I gained 300 XP today. I'm 500 XP from leveling up."

Your brain interprets this as: "I'm moving forward."

Variable Ratio Reinforcement

B.F. Skinner discovered that unpredictable rewards create the strongest behavioral patterns.

This is why slot machines are addictive. You don't know when you'll win, so you keep pulling the lever.

In gamified productivity:

Some tasks give small XP (quick wins)

Some give large XP (major milestones)

Occasionally you level up (big dopamine hit)

Sometimes you unlock achievements (unexpected rewards)

This unpredictability keeps your brain engaged in a way that "check the box, done" never could.

The Endowed Progress Effect

Joseph Nunes and Xavier Drèze ran an experiment: They gave people loyalty cards for a car wash.

Group A: "Complete 8 washes, get one free"

Group B: "Complete 10 washes, get one free (you already have 2 stamps!)"

Both groups needed 8 more washes. But Group B completed the card at a 20% higher rate.

Why? Because they felt they'd already made progress.

In gamified systems:

Starting at Level 1 with 0 XP feels like you've already begun the journey. You're not starting from nothing—you're already a Level 1 character with a baseline of capability.

This small psychological shift increases follow-through dramatically.

Identity-Based Motivation

James Clear writes about this in Atomic Habits: "The ultimate form of intrinsic motivation is when a habit becomes part of your identity."

When you identify as "someone who works out," going to the gym isn't a chore—it's an expression of who you are.

Gamified productivity builds identity:

You're not "doing tasks." You're "leveling up your character." You're "completing quests." You're "purging glitches."

This sounds silly, but it works. Your brain starts to see the work as part of a larger narrative about who you're becoming.

My Results: The Data

I'm a developer, so of course I tracked everything.

Before Gamification (Jan-Mar 2025):

Average tasks completed per week: 11.2

Learning time per week: 2.1 hours

Days I avoided opening my task manager: 4-5 per week

Side projects completed: 0 in 6 months

After Gamification (Jul-Dec 2025):

Average tasks completed per week: 19.3 (+72%)

Learning time per week: 5.6 hours (+167%)

Days I avoided opening my task manager: <1 per week (-85%)

Side projects completed: 2 in 3 months

Same human. Same job. Same tasks.

The difference: how my brain responded to completing them.

What I Actually Built

Since people keep asking, here's the structure I landed on:

Character Sheet

Current Level (based on total XP)

Key Stats: Quests Completed, Glitches Purged, Learning Hours, Streak

Visual progress bar showing XP until next level

Quest System

Bounties: Quick tasks (15-30 min) → 10 XP

Quests: Medium work (1-3 hours) → 100 XP

Glitch Purge (Bug Tracker)

Bugs framed as "glitches" to purge

Severity = difficulty rating

20 XP per bug fixed (max)

Learning Paths

Courses/tutorials tracked as "skill trees"

Progress bars for each path

XP awarded per completed book/course

Linked Knowledge Base

Docs, code snippets, architecture decisions

Everything links to projects

No more "where did I write that note?"

Leveling Curve

Early levels are fast (keeps you engaged)

Later levels require exponentially more XP

Level 1→2: 500 XP

Level 10→11: 32,000 total XP

Level 20: 225,000 total XP

This prevents "just spam easy tasks" gaming.

The Skeptics' Questions (Answered)

"Won't the novelty wear off?"

Probably. For some people.

But here's the thing: the structure remains valuable even when the gamification feels less exciting.

The real power isn't in the XP. It's in:

Everything being linked (tasks → projects → docs → learning)

Visible progress tracking

Clear prioritization

Context that never gets lost

The gamification is the fun wrapper. The system underneath is the actual value.

"How do you prevent it from becoming another metric to stress about?"

By treating XP as feedback, not a goal.

I don't try to "maximize XP per day." I do the work that matters, and XP is just the signal that says "you made progress."

The moment you start optimizing for points instead of results, the system breaks. The key is using it as a motivational tool, not a performance metric.

"Isn't this just... lying to yourself?"

In a sense, yes.

But all productivity systems are "lies" in this way. They're artificial structures we impose on chaotic reality to make it more manageable.

The question isn't "is it a lie?" The question is "does it help?"

And for me, framing bug fixes as "glitch purges" helps. It makes the work feel less like drudgery and more like challenges to overcome.

If that's a lie, it's a useful one.

"What about people who don't like games?"

Fair. Gamification isn't for everyone.

But here's what surprised me: the underlying structure works even without the gaming layer.

The linked databases, the progress tracking, the clear prioritization—that stuff is valuable regardless.

The XP and levels are optional. The organization is essential.

Implementation Tips (If You Want To Try This)

Start Small

Don't gamify everything at once. Pick ONE area:

Task completion

Learning consistency

Bug fixing

Get that working first. Expand later.

Make XP Values Consistent

Quick tasks: 5-10 XP

Large Projects: 10-100 XP

Adjust to your preference, but stay consistent. The system only works if XP means something.

Level Curve Matters

Make early levels fast (Level 1→5 should take days, not months).

Make later levels require exponentially more XP (prevents feeling "stuck").

Link Everything

The real power is in connections:

Tasks link to projects

Projects link to docs

Learning resources link to docs

Everything traces back to your goals

This reduces context switching dramatically.

Don't Obsess Over Points

The system should energize you, not become another source of stress.

If you find yourself gaming the system just to get more XP, step back and remember: the work matters, not the points.

Track Actual Results

Measure what matters:

Tasks completed

Projects shipped

Learning hours logged

Side projects finished

XP is just the feedback mechanism. Real results are the goal.

When Gamification Doesn't Work

Let's be honest: this isn't a universal solution.

Gamification fails when:

The work itself is the problem. No amount of XP makes you excited about work you fundamentally don't care about. Fix the "what" before optimizing the "how."

You're already highly motivated. If you're in deep flow and crushing it, gamification adds friction. Use it when you need the boost, ignore it when you don't.

You treat it as the solution. Gamification doesn't replace discipline. It makes discipline slightly easier on the hard days.

You optimize for points instead of results. The moment XP becomes the goal, the system breaks. It's a tool, not a scoreboard.

The Bigger Lesson

Here's what I learned from three months of gamified productivity:

Your productivity system should respect the reality of how your brain actually works.

Not how it "should" work according to some productivity guru. How it actually works.

My brain:

Needs to see progress visually

Responds to immediate feedback

Gets demotivated by negative framing

Loves a good narrative

Traditional task managers gave me none of that. Gamification gave me all of it.

Your brain might be different. And that's fine.

The point isn't "everyone should gamify." The point is "find what actually motivates YOU and build your system around that."

For some people, it's gamification. For others, it's minimalism. For others, it's detailed planning.

There's no one-size-fits-all. Stop looking for the "perfect" system and start looking for YOUR system.

Conclusion: The Unlikely Convert

I started this experiment as a skeptic.

"Gamification is for people who can't motivate themselves," I thought.

Three months later, I'm the person who gets genuinely excited when I level up in my task manager.

Does that make me less disciplined? Maybe.

But it also makes me more productive, more consistent, and less burned out.

And in the end, results matter more than aesthetics.

If adding XP to my bug fixes makes me actually want to fix them, I'll take the imaginary points over the clean minimalist task list that I never open.

Your productivity system should work for you, not against you.

Even if that means treating your workday like a video game.

Resources & Further Reading

Psychology Research:

Deci, E. L., & Ryan, R. M. (2000). Self-Determination Theory

Amabile, T., & Kramer, S. (2011). The Progress Principle

Skinner, B. F. (1953). Science and Human Behavior

Clear, J. (2018). Atomic Habits

Gamification in Productivity:

Deterding, S. (2012

). "Gamification: Designing for Motivation"

McGonigal, J. (2011). Reality is Broken: Why Games Make Us Better

My System: If you want to try a gamified system yourself, I built a Notion template based on these principles. It includes the XP system, linked databases, and all the structure I described above. There's a free version if you just want to experiment with the concept.

You can find it here.

Stop using Jira for side projects: A minimalist alternative.

Lux Seminare — Tue, 23 Dec 2025 00:46:46 +0000

Let’s be honest: Jira is for enterprise meetings, not for solo developers building on a Saturday night.

If you’ve ever spent more time configuring a sprint than actually writing code, you’ve experienced "Project Management Bloat." When you're building a side project, you don't need a corporate oversight tool. You need a Command Center.

The Problem with "Heavy" Tools

Most PM tools are built for managers, not creators. They prioritize reporting over shipping. For a solo dev, this leads to:

Context Switching: Jumping between 5 different apps to see your bugs, docs, and tasks.

Friction: Spending 10 minutes filling out fields for a bug that takes 2 minutes to fix.

The "Void": Closing a ticket feels empty. There’s no sense of progress.

The Minimalist Approach: The DevHub

I spent months trying to find a balance between "too simple" and "too complex." I ended up building the DevHub in Notion. It’s designed around a single philosophy: Stay in one place.

Instead of complex workflows, it uses a Bug Tracking system (Open → In Progress → Testing → Resolved) and a Task Database for managing tasks.

GET THE BASIC VERSION

I’m a big believer in building in public and giving back to the community. I’ve released a Basic version of the DevHub that includes the core Central Command Hub, The Project, Tasks, Bug Tracking, Docs, and Learning Resources database.

You can grab the Basic version here and start cleaning up your workflow today.

Why It’s Different

Linked Database Architecture: Your bugs, projects, tasks, docs, and learning resources are connected. No more "where did I put that technical spec?"

Reduced Cognitive Load: One dashboard. Everything you need for the day is surfaced automatically.

If you’re tired of fighting your tools, stop using enterprise software for your dream projects. Keep it lean, keep it fast, and keep shipping.

What’s your current stack for managing side projects? Let’s talk in the comments.

buildinpublic #productivity #notion #developer

[BUILD IN PUBLIC] Notion Dev Hub: The Final Countdown (48 Hours until Launch!)

Lux Seminare — Sun, 14 Dec 2025 14:54:20 +0000

Quick update, folks! The Notion Developer's Hub is fully polished and launching in just two days.

What to expect: A powerful free core template, and the full feature set (including the Gamified Habit Tracker and Reflection system) in the premium version.

Thank you for being part of the journey. Launch is T-48 hours!

Set your reminder and grab a launch deal: https://luxdevhub.carrd.co/