Process Ongoing Improvement in IT: A Practical System for Tracking and Prioritizing Tasks

Introduction

In the fast-paced world of IT, managing cross-functional teams efficiently is a constant challenge. With multiple stakeholders, tight deadlines, and ever-changing requirements, it’s easy for teams to lose focus and productivity. However, by applying principles from the Theory of Constraints (TOC) and Process Ongoing Improvement (inspired by Toyota’s practices), we can create a system that not only tracks tasks but also prioritizes them effectively. In this article, I’ll share a practical system we’ve implemented using Jira to improve productivity, identify bottlenecks, and ensure continuous improvement.

The Problem: Why Traditional Approaches Fall Short

Traditional task management systems often fail to address key issues in IT teams:

• Bottlenecks: Tasks get stuck in one stage (e.g., testing or design review), delaying the entire workflow.

• Overloaded Teams: Developers, testers, and designers are often overwhelmed with tasks, leading to burnout and missed deadlines.

• Lack of Visibility: Without clear tracking, it’s hard to identify which tasks need immediate attention.

• No Continuous Improvement: Teams often focus on "putting out fires" rather than improving processes.

To solve these problems, we developed a system that combines time tracking, color-coded prioritization, and data-driven analysis, all while focusing on the bottleneck—the resource with the lowest productivity.

The System: How It Works

Simple initial development flow:

1. Estimating Task Time

During Refine Meetings, the team estimates how much time each task (ticket) will take for:

• Development
• Testing
• Design Review

These estimates are based on historical data and team input, ensuring they are realistic.

2. Accounting for Non-Productive Time

We recognize that team members are not 100% productive due to meetings, discussions, and other activities. To account for this, we multiply their available time by a productivity coefficient (0.8 or 0.85). For example, if a developer has 40 hours in a week, their effective working time is 32-34 hours.

3. Identifying the Bottleneck

The bottleneck is the resource with the lowest productivity (e.g., testing or design review). By identifying it, we can focus our efforts on optimizing the constraint that limits our maximum productivity.

4. Applying the 5 Steps of TOC (Goldratt)

To manage the bottleneck, we use the 5 steps of TOC:

1. Identify the bottleneck: Find the constraint in the system.
2. Exploit the bottleneck: Maximize its efficiency (e.g., reduce downtime).
3. Subordinate everything else: Align the entire system to the bottleneck.
4. Elevate the bottleneck: Increase its capacity (e.g., add resources).
5. Repeat the process: Continuously improve the system.

5. Color-Coded Prioritization

Each ticket is tracked based on its progress relative to the estimated time:

• Green: Less than 33% of the estimated time has passed.
• Yellow: Between 33% and 66% of the estimated time has passed.
• Red: Between 66% and 100% of the estimated time has passed.
• Black: More than 100% of the estimated time has passed.

This system allows the team to quickly identify which tasks need immediate attention.

From current system:

It becomes system with priorities:

6. Handling Blocked Tickets

If a ticket is blocked (e.g., waiting for input from another team), the clock keeps ticking. This creates urgency to resolve dependencies quickly before the ticket turns black. It also highlights areas for improvement in cross-team collaboration.

7. Tracking Rework

When a ticket requires rework, the team manually logs the reason (e.g., "design changes," "bug found during testing"). This data is later analyzed to identify recurring issues and improve processes.

8. Adding a Time Buffer

To account for unexpected delays, we add a 15% time buffer to each stage (development, testing, design review). This ensures the team has some flexibility without overcommitting.

Benefits of the System

1. Transparency: Everyone can see the status of tasks at a glance.
2. Focus on Constraints: The team prioritizes tasks that are at risk of delay (black and red tickets).
3. Data-Driven Improvement: By analyzing rework reasons, the team can identify and address systemic issues.
4. Realistic Planning: Accounting for non-productive time and adding buffers makes planning more accurate.
5. Continuous Improvement: The system encourages teams to reflect on their processes and make ongoing adjustments.
6. Bottleneck Management: Knowing the bottleneck allows us to optimize the entire workflow using TOC principles.

Example from Practice

In our team, this system helped reduce the average time to complete a ticket by 20%. By focusing on black and red tickets, we were able to resolve bottlenecks faster. Additionally, the data on rework reasons revealed that 30% of delays were caused by unclear requirements, prompting us to improve our refinement process.

Tips for Implementation

1. Start Small: Pilot the system with one team before rolling it out company-wide.
2. Use Automation: Integrate Jira with time-tracking tools (e.g., Tempo, Clockify) to automate data collection.
3. Train Your Team: Ensure everyone understands the system and its benefits.
4. Regularly Review Data: Hold retrospectives to analyze rework reasons and identify areas for improvement.
5. Adjust as Needed: The system should evolve based on your team’s needs and feedback.

Conclusion

Managing productivity in IT teams doesn’t have to be a guessing game. By implementing a system that combines time tracking, color-coded prioritization, and data-driven analysis, you can ensure that your team stays focused, efficient, and continuously improving. Give this system a try, and let me know how it works for you!

Call to Action

What challenges does your team face in managing tasks? Have you tried similar systems? Share your thoughts in the comments below!