Taskmate
A chess-inspired personal Kanban board that turns progress into a journey from Pawn to King.
Status
Focus
Full Stack, Product Experiment
Primary Stack
Python + FastAPI
Type
Case Study
Product at a glance
See progression in action
Four screens show Taskmate’s fixed Kanban workflow, task editing, King completion feedback, and compact player statistics.
Overview
Overview
Taskmate is a personal productivity MVP built around a fixed six-stage workflow. Users move tasks from Pawn to King, earn rating points for forward progress, and get a clear completion moment when a task reaches the final stage.
Personal boards with task CRUD, priorities, due dates, and tags
Six-stage Pawn-to-King workflow with adjacent-move rules
Rating, movement history, player stats, and completion feedback
Cookie sessions and bearer-token auth with backend and E2E tests
Motivation
Why I Built It
Taskmate is a product experiment around personal momentum. A normal task list can tell you what exists, but it does not necessarily make movement feel visible. The project uses a chess metaphor to turn progress into a small, legible journey.
The goal is not to make work into a game for its own sake. It is to explore whether a fixed workflow, clear movement rules, and immediate feedback can make personal execution easier to follow.
Problem
The Problem
Problem statement
Many personal task lists show what exists without making progress feel tangible. Taskmate explores a focused workflow where stage rules, visible movement, and feedback make steady progress easier to follow.
Many personal task tools are passive: add a task, see it again, and decide for yourself what progress means. That flexibility is useful, but it can also make a workflow feel vague.
Taskmate tests a more opinionated model. Every task moves through six named stages, so progress has a visible position and a clear next step.
Solution
The Solution
The frontend is built with Next.js, React, TypeScript, and Tailwind CSS. The FastAPI and SQLAlchemy backend owns boards, tasks, authentication, movement rules, and player statistics.
The six stages run from Pawn to King. A task can move only one stage at a time; forward movement adds a rating point, backward movement removes one without going below zero, and reaching King triggers the completion feedback. SQLite is the local default and PostgreSQL is supported for deployment.
Stack
Tech Stack
Decisions
Technical Decisions
Make movement rules part of the domain
The adjacent-stage rule is enforced by the backend rather than being left to the interface. That means a direct API client cannot skip the workflow, and the rating change has one authoritative place to follow.
Use a fixed six-stage workflow
Custom stages would add flexibility, but they would weaken the product experiment. Keeping Pawn, Knight, Bishop, Rook, Queen, and King fixed makes the path easy to understand and gives the feedback system a stable structure.
Keep browser and API authentication paths explicit
The app uses an HttpOnly session cookie in the browser and also supports bearer credentials. That keeps the frontend experience simple while allowing backend, integration, and automation tests to authenticate directly.
Treat the OpenAPI document as a checked-in artifact
The API contract describes the boundary between the Next.js client and FastAPI service. Keeping it in the repository makes the behavior easier to inspect, test, and change deliberately.
Challenges
Challenges
Making invalid movement impossible to ignore
A progress system only works if its rules are consistent. The backend tests cover forward movement, backward movement, invalid jumps, rating changes, and the path all the way to King so the feedback cannot drift from the workflow.
Keeping local development approachable
Taskmate includes a frontend, backend, database configuration, a container path, and end-to-end tests. Clear defaults and repository-level commands reduce the setup cost while preserving a realistic integration path.
Separating product feedback from task state
Sounds, animation, rating changes, and the victory overlay make movement feel meaningful, but the task state still has to remain predictable. Keeping the domain state in the backend lets the interface add energy without becoming the source of truth.
Lessons
What I Learned
Product constraints can make progress easier to understand when they are intentional.
Rules that affect user state belong in the backend and should be tested as journeys.
A metaphor works best when it clarifies the workflow instead of hiding it.
A clear local default is a feature for both users and contributors.
Status
Current Status
iterating
Taskmate is an active MVP under iteration and is deployed on Render. The live site is available above, while the source repository documents the local, container, and test paths.
Architecture
System Design
Taskmate — current repository shape
Next.js / React frontend
FastAPI backend
Domain model