Everyone takes on the role of a project manager at some point. Whether you’re spearheading the creation of a new application for your startup, overseeing a billion-dollar enterprise project, or simply aiming to revamp your yard with a DIY landscaping project, you’re essentially managing a project.

The triumph of your project hinges on various elements, but a prevalent cause for project failure is inadequate management or downright poor project management. Regardless of your team’s size or the clarity of your documented requirements, neglecting proper team management will likely lead to project failure.

Agile project management has gained widespread adoption as a method for tackling modern software development projects. But what exactly does Agile entail?

For a more comprehensive exploration of Agile principles, I recommend delving into our Ultimate Guide to Agile Project Management.

This particular post will elucidate the fundamentals of agile project management using Kanban.

Even seasoned project managers well-versed in agile principles can benefit from revisiting and reinforcing these core concepts. The software development landscape is characterized by ever-accelerating innovation cycles, which in turn escalate project management complexity with each iteration. Returning to and solidifying fundamental Agile principles is perpetually crucial. After all, repetition is the foundation of knowledge.

Kanban stands out as one of the most straightforward methods for managing Agile software development projects. It can effortlessly accommodate both local development teams operating from a shared office and geographically dispersed teams spanning multiple time zones.

It’s important to note that Kanban is not a process in itself. Rather, it’s a management approach applicable to any process with minimal disruption to the team’s established operational procedures.

To integrate Kanban principles into your workflow, you need to apply two fundamental rules:

1. Visualize your process.
2. Limit work in progress.

Visualize Your Process

Data visualization offers a rapid and efficient means of conveying information universally and comprehensibly. When presented with visual aids, the human brain can process multiple pieces of information concurrently. Some studies suggest that this visual processing can be up to 60,000 times faster than text-based information absorption.

A Kanban Board is the most prevalent method for process visualization. It consists of a board segmented vertically into multiple columns, with each column representing a distinct stage within your process.

Let’s illustrate this with a simplified software development board. First, we need to outline the states our development features will transition through:

1. To-Do: The feature awaits development.
2. Development: A developer is actively working on the assigned feature.
3. Quality Assurance: The feature is undergoing review.
4. Deployed: The feature has been accepted and integrated into the application release.

Based on these states, your board should adopt the following structure:

Visualizing individual tasks is as simple as generating a card (resembling a Post-it note) to represent a work item requiring attention. This card can include the task name, assigned developer, due date, and any other pertinent details.

Placing this card within a column on the Kanban Board visually represents, for instance, that a specific developer is currently engaged in a particular task, due on a specific date, and presently in the development phase.

Limit Work In Progress (WIP)

The concept of human multitasking is a misconception. Instead of concurrently focusing on multiple tasks, our brains rapidly switch between them.

This phenomenon is particularly evident in software development. Developers can only effectively work on one code segment at a time. Shifting to another feature introduces delays and negatively impacts their concentration and overall performance.

However, this doesn’t imply restricting assignments to a single task at a time. Development is inherently complex and creative, with tasks varying in completion time. Additionally, delays can arise while developers await resources or input from others. The key is to constrain assigned tasks to a manageable number that avoids creating chaos (typically three to five tasks concurrently).

Assuming your development team consists of two developers and a QA engineer, your board might incorporate the following WIP limits:

• To-Do: Unlimited
• Development: Six-card limit (Each developer limited to a maximum of three tasks)
• Quality Assurance: Three-card limit (QA engineer limited to a maximum of three cards)
• Deployed: Unlimited

As the project manager, it’s your responsibility to ensure the To-Do list is appropriately prioritized, and tasks are assigned to developers only when necessary.

A well-managed Kanban Board provides a clear snapshot of your project’s status at any given moment. You can readily ascertain whether your developers have a sufficient workload, if you’ve prepared new tasks for them to seamlessly transition to upon completing their current assignments, and if your QA engineer is poised to commence reviewing new tasks.

Use Trello to Manage Your Kanban Board

Trello](https://trello.com/) is a web-based Kanban project [management application that facilitates seamless real-time collaboration among team members, even across multiple teams and projects.

To create a board in Trello, simply click the “Create new board …” menu item and provide a descriptive title for your board.

Initially, you’ll be presented with an empty board. Utilize the “Add list …” box to create columns dedicated to housing your Kanban cards.

Clicking “Add a card…” at the bottom of any list allows you to effortlessly create a task. Each card you generate should represent a specific task designated for execution by a team member.

Trello’s cards offer a high degree of customization:

• Assign team members responsible for task execution.
• Color-code cards to visually categorize them based on specific groupings.
• Establish due dates.
• Attach relevant files.
• Incorporate custom fields such as checklists to track the progress of smaller task components.
• Team members can engage in card-based discussions, and everyone involved will receive notifications regarding any modifications made.

Given the paramount importance of visualization in Kanban, here’s a visual representation of how a card appears on the board:

A cursory glance at the card, even without delving into the detailed view, reveals the following:

1. The “Setup GitHub Code Repository” task is pending execution within the To-Do list.
2. The task’s due date is set for January 27.
3. A description accompanies the task.
4. There’s one comment associated with the task.
5. A checklist comprising two items is included, and none of these items are currently marked as completed.
6. The task is assigned to user DS, indicating they will be the next to work on it.
7. The task belongs to a group of green-colored cards, signifying its prerequisite nature before project initiation.

Estimate Time And Complexity of Development Work

Effective project planning and management are impossible without a grasp of the effort and time required to complete specific tasks. However, accurately predicting the delivery timeline for a new software product or feature remains one of the most challenging aspects of software development.

Scrum, a widely embraced Agile principle, heavily relies on estimations, whether expressed in terms of time or “complexity points.”

The team should dedicate ample time to thoroughly scoping out each task.

This emphasis on estimation stems from Scrum’s foundation on time-boxed intervals, where a defined set of tasks is expected to be finalized within a specific timeframe. Accurate delivery planning necessitates a comprehensive understanding of all work slated for that time-box.

In contrast, Kanban doesn’t hinge on time-boxed deliveries. You have the flexibility to plan for daily delivery if desired. Its focus lies in flow optimization, meaning the team prioritizes completing and clearing the WIP column as swiftly as possible.

Consequently, teams employing Kanban don’t invest heavily in upfront work estimation. A developer selects the next item from the To-Do list, completes it expeditiously, and then proceeds to the next task.

However, this doesn’t imply that teams should completely disregard workload estimation.

Regular weekly or daily calls can be leveraged to update and validate due dates.

Nonetheless, for smaller teams, the primary focus should be on ensuring developers are consistently engaged in the highest-priority tasks and that bottlenecks hindering their progress are promptly addressed.

As your project scales and demands more granular development work estimation, referring to our guide on Software Costs Estimation In Agile Project Management can provide valuable insights.

Must-have Management Practices

Thus far, we’ve covered the significance of process visualization, WIP limitations, and leveraging Trello for project management.

However, software projects extend beyond cards and columns, necessitating the implementation of Agile best practices:

• Regular Team Meetings: Conduct at least weekly meetings to review accomplishments, refine the backlog (To-Do list), and prioritize tasks as needed. These meetings ensure team-wide synchronization, facilitate idea exchange, and benefit from the presence of a project stakeholder (client, company CTO, or product team representative) who can provide non-technical feedback and make informed decisions.

• Constant Communication: Foster seamless communication channels with individual team members to streamline daily operations. Keep these interactions brief and focused, even a quick update via your preferred chat application suffices. Daily check-ins, ideally ~15-minute meetings, can prove highly beneficial. During these check-ins, each team member provides a concise update stating:

Actively listen during these calls, take notes, and remain vigilant for potential roadblocks (blockers, misaligned task focus, unforeseen technical challenges), addressing them collaboratively with the team.

Bootstrap Your Software Development Project

While every software development project exhibits unique characteristics, certain tasks are nearly universal. Here are some essential tasks to incorporate into your software development project initiation:

• Version Control and Repository Setup: Tracking code changes and monitoring the codebase are paramount, particularly in collaborative environments where multiple individuals contribute to the same code. GitHub stands out as a leading code versioning service. GitHub, a web-based Git repository hosting service, offers comprehensive distributed version control and source code management (SCM) functionality inherent to Git. It provides access control mechanisms and a suite of collaboration features encompassing bug tracking, feature requests, task management, and project-specific wikis.

• Database Backup Policy: Services like GitHub inherently ensure regular code backups. However, databases typically fall outside the purview of version control systems, necessitating the implementation of frequent database backups. The development process is inherently prone to errors, and accidental data updates during development are not uncommon. Having a backup mechanism in place mitigates the impact of such occurrences.

• Collaboration and File Sharing: Project documentation, functional specifications, design files, and other project-related documents and files undergo constant updates and require distribution to your team. A plethora of services can facilitate this file sharing. Google provides a straightforward and cost-effective solution through Google Drive, Google Docs, Google Sheets, and other Google Workspace applications, enabling seamless file sharing and collaboration.

• Dedicated Development and Testing Environments: Maintaining an uninterrupted development workflow is crucial. Developers should not be hindered by waiting for application testing results; they should continue progressing on their assignments while Quality Assurance rigorously evaluates completed functionalities. Simultaneously, clients should have the ability to assess the application’s current state without being constrained by the development team’s progress. Establishing a dedicated test server that’s regularly updated eliminates bottlenecks, ensuring an uninterrupted workflow for your team.

• Scheduled Team Communication: Establish fixed times for weekly team calls and daily team catch-up calls or chats. Encourage all team members to block these times on their calendars, fostering a structured schedule that minimizes work interruptions.

Takeaway

Project management can be intricate and often highly demanding. Injecting structure and ensuring project status transparency and accuracy at all times significantly alleviate this stress. Embracing the Kanban method, adhering to Agile principles, and leveraging the right tools can yield substantial time savings.

However, it’s crucial to acknowledge that no tool or methodology can substitute for the dedicated time and effort a project manager must invest in project oversight.

Furthermore, the misconception that smaller projects inherently demand less attention can lead to significant headaches down the road.

To gauge whether your project is effectively managed, consider this straightforward checklist:

1. Is your process effectively visualized?
2. Are WIP limits in place for each team member, and are they minimized?
3. Does your team adhere to consistently scheduled meetings, whether weekly or daily?
4. Is your Kanban board updated regularly to reflect the project’s current state?
5. Do you have a code repository in place for version control?
6. Have you implemented a robust database backup strategy?
7. Are team communication and collaboration tools set up and actively used?
8. Is your development environment segregated from testing, acceptance, and production environments?

Bear in mind that this list is not exhaustive; it merely scratches the surface.

We encourage you to share your thoughts, tips, and practices in the comments below, contributing to a valuable resource for aspiring project managers embarking on the perpetual journey of empowering software development teams.