Job Application Tracker

Building My Job Tracker with Agile Principles

For anyone looking to pivot into Project Management, the biggest question is often, "How do I prove I have the skills before I have the title?". A resume can list competencies like "planning" and "risk management," but showing them in action is the real challenge.

This project was born from that exact question. The goal was simple: to treat a personal software project with the same professional rigor as a real-world program, creating tangible artifacts that showcase those critical, transferable skills.

This post is a case study of that experiment. We'll walk through the end-to-end lifecycle of building a simple "Job Tracker" application, not just as a coding exercise, but as a formally managed project.

The Final Product: A Personal Kanban Board for Your Job Applications

The result of this process is a clean, functional, single-page web application that helps users manage their job applications on a simple Kanban board.

Case Study

Core Features:

• Add & Manage Jobs: Easily add new job opportunities with key details.
• Visual Kanban Board: Track applications across five stages: Wishlist, Applied, Interviewing, Offer, and Rejected.
• Drag-and-Drop Interface: Intuitively update a job's status by dragging its card to a new column.
• Secure Cloud Storage: All data is saved to a personal, secure cloud database via Google Firestore.

The Core: The Project Management Lifecycle in Action

The true "product" of this endeavor was the process itself. Here’s how we went from a simple idea to a deployed application, with each step documented and managed.

The Vision (The Project Charter)

Every successful project begins with a clear, shared understanding of its goals. Before any work began, we established a formal Project Charter. It served as our guide to make informed decisions, defining the project's vision, a realistic MVP scope, and success metrics. This document acted as an official map that kept us from wandering off into the wilderness of other good ideas :D

The Blueprint (The Product Backlog)

With a clear vision, we translated our goals into a detailed Product Backlog. I authored each task as a user story with explicit Acceptance Criteria, which was a crucial step in eliminating ambiguity and ensuring that 'done' meant the same thing to everyone.

The Workflow (The Kanban Board & Delegation)

To manage development, we used a GitHub Projects Kanban Board. This provided complete transparency into the status of every task ("To Do," "In Progress," "Done").

A key success factor was the ability to delegate effectively. By clearly defining backend and frontend tasks in the backlog, I was able to manage my own work on the backend API while seamlessly assigning UI tasks to a dedicated frontend developer. This clear separation of responsibilities enabled parallel workstreams and was critical for our efficiency.

Navigating Roadblocks: A Project Manager's Intervention

Of course, no project is a straight line from 'To Do' to 'Done'. We hit a couple of interesting hurdles that required moving from planning to active problem-solving.

1. The Security Block:

• The Problem: The application was blocked by a Missing or insufficient permissions error. Our app could connect to the database, but any further interactions with the database were not possible.
• The PM Intervention: Instead of treating this as a simple code bug, I triaged the issue and identified it as a foundational security configuration problem. To manage this, I created a formal Bug Report to document the problem and a new high-priority task to implement production-ready security rules. This ensured the problem was tracked, prioritized, and resolved correctly without derailing other development work.

2. The User Experience Flaw:

• The Problem: The app worked, but key interactions felt slow and unresponsive. There was a noticeable delay between saving a new job and seeing it appear on the board.
• The PM Intervention: I identified this as a critical user experience flaw that violated our goal of creating a "streamlined" tool. I facilitated a discussion that shifted the focus from "does it work?" to "does it feel good to use?". This led to the decision to prioritize the user experience and implement an "optimistic UI update", which made the application feel instantaneous and professional.

The Reflection: Key Learnings

At the end of the project, we conducted a Project Retrospective to reflect on the process. The key takeaways were:

1. Process Creates Predictability: While a structured process may feel like a slow start, it offers clarify by creating a predictable path to a successful outcome.
2. Security isn't a Feature; It's a Foundation: Security planning must happen at the beginning of a project, not as a reaction to an error.
3. The User Experience is Paramount: A feature that is functionally correct but feels slow is still a broken feature.

Ultimately, this project was an exercise in building more than just an app; it was about building experience. By intentionally managing each phase, from authoring the initial Project Charter to navigating the final Project Retrospective, I was able to learn and demonstrate a wide range of project management competencies:

• Strategic Planning: Authoring a comprehensive Project Charter to define scope and align stakeholders.
• Agile Execution: Managing a sprint using a detailed backlog and a Kanban board.
• Risk & Issue Management: Identifying, documenting, and resolving critical security and user experience blockers.
• Team Delegation: Effectively coordinating between backend and frontend development workstreams.
• Continuous Improvement: Conducting a formal retrospective to capture key learnings for future projects.