Project Management Tracker
Last reviewed
IntermediateWhat you'll learn
~90-120 min- Build a full-featured project management application with Kanban, Gantt, and burndown views
- Understand how state management drives multiple synchronized views of the same data
- Apply Agile project management concepts (story points, velocity, WIP limits) in a hands-on tool
- Use localStorage for client-side data persistence and JSON export/import for backup
What you’re building
Project management is the backbone of MIS work. Whether you are managing a software implementation, coordinating a database migration, or running a capstone project, you need to track tasks, deadlines, and team workload. Tools like Jira and Asana require accounts and come with a learning curve that eats into the time you should spend managing the project itself.
In this lesson you will build a full-featured project management tracker as a React application. It includes a Kanban board with drag-and-drop, a Gantt chart timeline view, team member assignment, milestone tracking, and a burndown chart. All data persists in localStorage — no server, no database, no login. Open it in a browser and start managing.
This is not a toy demo. By the end of this lesson you will have a tool that can serve as a strong personal or small-team tracker and a standout portfolio project.
The showcase
When finished, your app will have:
- Kanban board: columns for Backlog, To Do, In Progress, Review, and Done. Drag cards between columns. Each card shows task name, assignee avatar, priority badge, and due date.
- Gantt chart view: horizontal timeline showing all tasks as bars, colored by status. Dependencies shown as arrows between bars. Zoom to day/week/month granularity.
- Burndown chart: tracks completed story points over time against the ideal line. Shows whether the project is on track, ahead, or behind schedule.
- Task detail modal: click any task to see full details — description, assignee, priority (Low/Medium/High/Critical), story points, due date, subtasks checklist, and activity log.
- Team panel: list of team members with workload indicators (how many points assigned, how many tasks in progress).
- Milestone tracker: define milestones with target dates, see percentage completion based on linked tasks.
- Filters and search: filter the board by assignee, priority, or label. Search tasks by name.
- Data persistence: everything saves to localStorage automatically. Export/import as JSON for backup.
Professional environments and capstone projects both require structured project tracking. The Kanban methodology you are implementing here is an Agile framework used at companies from startups to Fortune 500. Understanding how a Kanban board works at the code level — state transitions, WIP limits, velocity tracking — gives you a deeper understanding than just dragging cards in Jira. When an interviewer asks “How do you manage projects?”, showing a tool you built yourself is a powerful answer.
Before you start
First, if your AI tool is still open, leave it: type /exit and press Enter (if you use Antigravity, press Ctrl+D with nothing typed instead), and wait until you see the $ or % prompt. Make a clean folder for this lesson inside your course folder:
mkdir -p ~/mis-workbench/03-project-management-tracker && cd ~/mis-workbench/03-project-management-trackerOn Windows PowerShell, run mkdir -Force ~/mis-workbench/03-project-management-tracker; cd ~/mis-workbench/03-project-management-tracker, or open the folder in your desktop agent app. Then start your agent the way your track’s setup lesson showed.
Switch to plan mode
Once your agent is open, switch to Plan mode inside the session (Shift+Tab, /plan, or your desktop app’s mode picker). In plan mode it asks clarifying questions and shows you a plan before building.
The conversation
Each message below is an example. Say it in your own words.
Say what you want
Start with a short plain-English description of what you want to build:
I want to build a local project management web app with a drag-and-drop Kanban board, a Gantt timeline chart with dependencies, a burndown chart, and team workload tracking. Ask me what you need first.Answer its questions
Your agent will ask a few questions to clarify the design and features. Answer each briefly:
| If it asks | You might say |
|---|---|
| What tech stack and styling should we use? | Use whatever web tools and charting library run best locally, in a clean dark theme. |
| Which Kanban columns and card details do you want? | Backlog, To Do, In Progress, Review, and Done, showing assignee, priority, due date, points, and WIP limits. |
| What should the Gantt and burndown views show? | A timeline with dependency arrows and day/week/month zoom, plus ideal versus actual story point burndown. |
| How should project data be stored and backed up? | Save changes automatically in my browser, with export and import buttons for backup files. |
| Should we include sample data so it works right away? | Yes, add a Load Demo Project button with a Website Redesign project of 20 tasks and 4 milestones. |
Read the plan
Before approving, check the plan for four domain essentials:
- One shared store drives all views. Moving a task card to Done on the Kanban board immediately updates the Gantt chart status color, the burndown chart’s completed story points, and the team workload counts.
- Completed tasks record a timestamp. Each task sets a
completedAtdate when moved to Done (and clears it if moved back) so the burndown chart steps down on the actual completion days rather than drawing a flat line. - Gantt bars and dependency arrows scale cleanly. Tasks position by start and due dates along a scrollable SVG timeline with day, week, and month zoom, a vertical Today line, and arrows connecting dependent tasks.
- Everything stays local in the browser. Changes auto-save to
localStorage, JSON export and import allow backups, and the demo project loads realistic tasks, milestones, and team members in one click.
If the first plan leaves out the completion date tracking or the demo project button, say so briefly:
Record the completion date whenever a task moves to Done so the burndown chart steps down by day, and include a Load Demo Project button.When the plan covers all four, approve it: pick the option to proceed or say Yes, go ahead and build it (in Codex, press Shift+Tab first to leave plan mode). Once you verify it runs cleanly in your browser, ask your agent to save a Git checkpoint:
Save a checkpoint with Git so we can roll back if needed.This is the largest React build in the MIS track, and it takes the agent longer than Lessons 1 and 2. If the output seems incomplete (missing the Gantt chart or burndown), send a follow-up message asking it to add the missing view from the plan.
What you get
The LLM will generate a project structure like this:
REFERENCE PROJECT LAYOUT project-tracker/ generated React + Vite project folder tree open reference hide reference Reference example of the folder layout your agent creates. Open to inspect how the store, utilities, and views are organized; you do not create these files by hand.
project-tracker/├── index.html├── package.json├── tsconfig.json├── vite.config.ts # includes the @tailwindcss/vite plugin├── src/│ ├── main.tsx│ ├── App.tsx│ ├── index.css│ ├── types.ts│ ├── store/│ │ ├── projectStore.ts # state management (Zustand or Context)│ │ └── localStorage.ts # persistence layer│ ├── utils/│ │ ├── burndown.ts # burndown calculations│ │ ├── gantt.ts # Gantt layout calculations│ │ └── demoData.ts # sample project data│ └── components/│ ├── KanbanBoard.tsx│ ├── KanbanColumn.tsx│ ├── TaskCard.tsx│ ├── TaskModal.tsx│ ├── GanttChart.tsx│ ├── BurndownChart.tsx│ ├── TeamPanel.tsx│ ├── MilestoneTracker.tsx│ ├── FilterBar.tsx│ └── Header.tsxAsk your agent to install the dependencies, start the local preview server, and give you the address to open:
Install what this app needs, start the local preview server, and tell me the browser address to open.If you prefer running it yourself in a terminal instead:
cd project-trackernpm installnpm run devOpen the local address (usually http://localhost:5173) in your browser. Click Load Demo Project to see the Website Redesign project.
Expected behavior with the demo project
- The Kanban board shows 20 tasks distributed across all five columns. Some cards show red due dates (overdue tasks) and critical priority badges.
- Drag a card from “In Progress” to “Review” — it snaps into place with a smooth animation.
- Switch to the Gantt chart tab. You see task bars laid out on a timeline. Dependency arrows connect related tasks. The red “today” line shows where you are.
- Open the Reports tab. The burndown chart shows the ideal line sloping down and the actual line stepping down unevenly — a realistic pattern for any project.
- Click a team member in the Team panel. The board filters to show only their tasks.
Common issues and fixes
| Problem | Follow-up prompt |
|---|---|
| Drag-and-drop not working | I cannot drag task cards between columns on the Kanban board. Please fix drag-and-drop so moving a card to a new column updates its status right away. |
| Gantt bars not aligning with dates | The Gantt chart bars do not line up with their start and due dates on the timeline. Fix the date positioning so each task bar spans its exact calendar dates. |
| Burndown chart flat | The burndown chart shows a flat line even after I move tasks to Done. Record the completion date when a task finishes so the burndown line steps down on each completion day. |
| Changes lost on refresh | My changes disappear when I refresh the page. Save all project changes in the browser automatically and reload them when the page opens. |
When things go wrong
Project management tools have complex state interactions — a status change on the Kanban board should update the Gantt chart, burndown, and team workload simultaneously. Here are the most common issues and how to diagnose them.
When Things Go Wrong
Use the Symptom → Evidence → Request pattern: describe what you see, paste the error, then ask for a fix.
Understanding the architecture
Here is how the key pieces work:
State management: The app uses a centralized store (likely Zustand or React Context + useReducer) that holds all tasks, team members, milestones, and project settings. Every component reads from and writes to this store. Changes trigger re-renders across the board, Gantt, and reports simultaneously.
Drag-and-drop: The @dnd-kit library handles the interaction layer. When you pick up a card, it creates a drag overlay. When you drop it over a new column, the library fires an onDragEnd event with the source and destination. The handler updates the task’s status in the store.
Gantt chart: Pure SVG rendering. Each task becomes a <rect> element positioned by its start date on the x-axis and its row index on the y-axis. Dependency arrows are <path> elements calculated from the end of one rect to the start of another. The zoom controls adjust the time scale (pixels per day).
Burndown calculation: On each render, the burndown utility counts total story points, then walks through the timeline day by day, subtracting points for tasks completed on each day. The ideal line is simply totalPoints - (totalPoints / totalDays) * dayIndex.
You might ask: why build a project tracker when Jira exists? Three reasons. First, understanding the mechanics of project management software makes you a better user of enterprise tools. Second, custom tools can be tailored to your exact workflow without paying for features you do not use. Third, building feature-rich applications like this is the kind of portfolio piece that gets you hired. MIS graduates who can both manage projects and build project management tools are rare and valuable.
🔍Agile Metrics That Matter: Beyond the Burndownclick to expand
The burndown chart is the most visible Agile metric, but project managers track several others. Understanding these will make you more effective in MIS project management courses and interviews:
- Velocity: The average number of story points completed per sprint. A stable velocity means the team is predictable. Erratic velocity signals estimation problems or scope changes. Your burndown chart reflects this — velocity is points completed per sprint, and the slope of the actual burndown line shows the burn rate over time.
- Cycle time: How long a task takes from “In Progress” to “Done.” Your Kanban board tracks this implicitly (when a task enters In Progress vs. when it enters Done). Lower cycle time means faster delivery.
- Throughput: The number of tasks completed per time period, regardless of size. Unlike velocity (which uses story points), throughput counts tasks. It is useful when teams struggle with estimation.
- WIP (Work in Progress): The number of tasks in active columns (In Progress + Review). High WIP leads to context switching and slower cycle times. Your tool supports WIP limits — try setting “In Progress” to a max of 3 tasks and see how it changes your workflow.
- Lead time: The total time from when a task is created (Backlog) to when it is completed (Done). This is the metric that stakeholders care about most: “How long from request to delivery?”
A strong portfolio addition: Add a “Metrics Dashboard” tab that calculates and displays these five metrics. The prompt: “Add a Metrics tab showing velocity trend (bar chart over sprints), average cycle time per status, current WIP count with limit warnings, throughput per week, and average lead time. Use Chart.js for all charts.”
Customize it
Add time tracking
Add a Log Time section and an hour estimate field to each task modal, plus a stacked bar chart in Reports showing weekly logged hours per team member.Add sprint planning
Add sprint management with two-week sprints, a Sprint Planning capacity view, sprint filtering on the burndown chart, and a velocity trend chart across completed sprints.Add calendar view
Add a monthly Calendar tab that shows tasks and milestones on their due dates, color-coded by priority, with drag-and-drop to reschedule.Add notifications and reminders
Add a header notification bell that alerts on tasks due tomorrow, overdue tasks, tasks moved to Review, and milestones due within three days.The architecture pattern here — centralized state, multiple views (Kanban, Gantt, Reports), role-based filtering, data persistence — mirrors how enterprise systems like SAP, Salesforce, and ServiceNow work internally. They are all CRUD applications with multiple presentation layers over a shared data model. When you work with enterprise systems, you will recognize these patterns because you have already built one.
Try it yourself
- Build the app by talking your agent through the plan above.
- Click Load Demo Project and explore all four tabs.
- Drag a task to Done on the Kanban board, then open the Reports tab to verify the burndown chart recalculates.
- Open the Gantt view and examine the dependency arrows. Do they make logical sense?
- Add a new team member and assign them some tasks. Check the workload indicator.
- Create a new milestone and link tasks to it. Watch the progress bar fill as you complete tasks.
- Export the project as JSON, then clear everything and re-import it. All data should restore perfectly.
- Pick one customization from the list above and add it with a follow-up prompt.
Key Takeaways
- Multiple views of the same data is the core pattern of enterprise software. The Kanban board, Gantt chart, burndown, and team panel all render from the same task store. Change a task in one view and it updates everywhere. This is how SAP, Salesforce, and every ERP system works.
- State management is the hardest part of interactive applications. The drag-and-drop interaction, task editing, filtering, and persistence all modify shared state. Getting this right is more important than making the UI look good.
- Agile is a framework, not just a buzzword. Story points, velocity, WIP limits, and burndown tracking are specific, measurable concepts. Building a tool that implements them gives you practical understanding that a textbook cannot.
- localStorage is surprisingly powerful for client-side tools. You get about 5 MB of persistent storage per site with zero server infrastructure. For personal and small team tools, this is often all you need.
- Complex tools are built from simple components. A Kanban board is just a list of lists. A Gantt chart is just rectangles on a timeline. A burndown is just a line chart. The complexity comes from connecting them, not from any single piece.
Portfolio Suggestion
A project management tracker is a standout portfolio piece because every hiring manager understands what it does — you do not need to explain the domain. To maximize impact:
- Deploy to Vercel or Netlify and include the live URL prominently on your resume.
- Load the demo project and take 3-4 screenshots showing the Kanban board, Gantt chart, burndown chart, and task detail modal. Use these in your portfolio site.
- Record a 60-second screen recording: load the demo, drag a task, switch to Gantt, show the burndown update. Post this to LinkedIn.
- If you are applying for project management roles, use this tool to actually track your capstone project. Export the JSON at the end and include it as an appendix in your capstone report, showing: “I built my own PM tool and used it to manage this project.”
- In interviews, frame it as: “I wanted to understand how Kanban boards actually work, so I built one. In the process, I learned about state management, drag-and-drop interactions, and Agile metrics like velocity and cycle time.”
Your burndown chart shows that the team has completed 30 out of 100 story points in the first 5 days of a 10-day sprint. The ideal line shows 50 points should be done by day 5. What does this tell you?
What’s next
In the next lesson, you will build a Business Report Generator — a Python CLI tool that takes a CSV file and outputs a polished executive report with auto-generated charts, summary statistics, and professional formatting. It automates the most repetitive deliverable in MIS coursework.