Tiny Ticket Types
Tags: agile, softwareengineering, projectmanagement, issuetracker
Published: 2024-01-23 21:40:35

---
title: Tiny Ticket Types
published: true
date: 2024-01-16 14:12:00 UTC
tags: Agiledevelopment,SoftwareEngineering,ProjectManagement,IssueTracker
cover_image: https://upload.wikimedia.org/wikipedia/commons/thumb/9/9c/Card_index_library.jpg/1201px-Card_index_library.jpg
canonical_url: https://suspensao.blog.br/disbelief/tiny-ticket-types/
---

Tickets in Jira tend to accumulate redundant and optional fields, becoming complex and confusing. I like Jira, but I understand the frustration it causes.

A plausible solution could be inspired by software development. We programmers are used to finding massive source files, and we know that breaking them into smaller files drastically improves code comprehension. Therefore, inspired by coding best practices, I suggest creating smaller tickets.

## Only three states

One way to limit the size of tickets is to simplify the workflow by restricting the number of states. For example, we can define that each type of ticket would have, at most, three states:

- To do
- In progress
- Done

To represent other stages, we can create new types of tickets, such as sub-tasks.

## A moderately complex ticket type

Let’s look at an example. Consider the ticket below:

![Key: XYZ-1234. Status: Testing. Title: Nasal demons. Description: Calling free() on a previosly dealocaded pointer results in demons coming out of the nose. Technical analysis: The root cause is an undefined behavior. Test results: The patch does not work, now ghosts pop out of the user’s ears. Release date: 2023-12-22](https://i0.wp.com/suspensao.blog.br/disbelief/wp-content/uploads/2024/01/ticke1-n.png?resize=652%2C426&ssl=1)

It would follow this workflow:

![Open ⇨ To do ⇨ In Analysis ⇨ Doing ⇨ Testing ⇨ Release ⇨ Done](https://i0.wp.com/suspensao.blog.br/disbelief/wp-content/uploads/2024/01/workflow-en.png?resize=646%2C189&ssl=1)

How could we reduce the number of phases?

We can start by removing the “In Analysis” stage. In its place, we create a new type of ticket called “Technical Analysis.” This way, the original task remains in progress (“Doing”) while the technical analysis is underway.

## Fewer fields in a ticket

An advantage of this would be transferring fields to sub-tasks. Fields that would clutter the original ticket can appear only in tasks where they are relevant.

Consider the “Release date” field, which only makes sense in the “Release” phase. If developers, testers, etc., are not responsible for the release, this field is confusing and pollutes the original task. With a new task type called “Release,” this field would be in the most appropriate place, keeping the original ticket concise.

## Repeating stages without regressing

Another advantage is that the original ticket can go through the same stage multiple times. It’s common for a ticket to have a development phase followed by quality tests, for example. However, if a problem arises in the evaluation, it’s not advisable to revert to the development phase. How to deal with this?

By working with sub-tasks, we can mark validation as completed and create a new implementation ticket. In our ticket, for example, we can remove the “Testing” phase and create a sub-task of type “Test,” as well as another one called “Development.” Every time the test fails, we close testing and open a new development task.

## Result

Following this strategy, our ticket would look like this:

![Key: XYZ-1234. Status: Doing. Title: Nasal demons. Description: Calling free() on a previosly dealocaded pointer results in demons coming out of the nose. Links: XYZ-1235 Technical analysis; XYZ-2345 Remove text in Latin; XYZ-3456 Test Latin removal; XYZ-2345 Use function medium(); XYZ-3456 Test medium() function; XYZ-4444 Release plan
](https://i0.wp.com/suspensao.blog.br/disbelief/wp-content/uploads/2024/01/ticket-2-en.png?resize=652%2C426&ssl=1)

And the workflow would be much simpler:

![Open ⇨ To do ⇨ Doing ⇨ Done](https://i0.wp.com/suspensao.blog.br/disbelief/wp-content/uploads/2024/01/workflow2-en.png?resize=510%2C57&ssl=1)

Naturally, this strategy is flexible. In our case, for example, we haven’t removed the “To do” phase yet. Restricting it to five (including backlog and validation) is another possibility. The core idea is to limit the number of stages to a small value for all tickets.

## Conclusions

In programming, it’s common to encounter the so-called “God objects,” huge objects responsible for various different functions. Breaking them down is a surefire way to achieve code quality. Therefore, I suspect the same principle can apply to tickets in Jira.

I’m not a project manager, but as a programmer, I believe that limiting the size and steps of tickets can be an effective idea. I’m curious to know if anyone has tried this and how it went.