Prioritization in Jira is quite basic and more often than not, companies choose to prioritize their backlogs elsewhere.

Foxly however is a backlog prioritization tool for Jira Cloud that brings prioritization back to where the work should happen. It helps align everyone in your team, and stakeholders, so they understand what the latest priorities are and why, and so everyone can participate in the prioritization process.

Teams use Foxly to prioritize anything, from product backlog to marketing activities, ideas or even to manage risks; you name it. If you’re not yet familiar with Foxly, you can read this article to understand why companies love it and give it a try (there's a 30-day free trial 🎉).

Because Foxly allows you to manage your priorities directly in Jira, you can make use of some cool automation rules that will help improve your prioritization process and remove the manual overhead.

Here are 4 automation rule ideas for your inspiration:

  1. Connecting Jira story points to the effort metric in Foxly
  2. Discounting score when the ticket is blocked (= flagged 🚩)
  3. Adding a new prioritization metric representing a number of tickets that the issue is blocking
  4. Using data from 3rd party apps in prioritization (eg. number of linked tickets from Intercom)

Let's have a closer look at each of these 🤓.

1. How to use the story points field in the priority scoring formula 🔢


Story points or complexity points are a common method used to estimate tasks in agile development teams. The story points field in Jira is available by default, and depending on the type of project you use, they can have different field names. In company-managed projects, it’s story points.  In team-managed projects, it’s called story point estimate and the field is only available if you enable the “estimation” feature in project settings.

In your prioritization process, you might find that you can use story points to represent metrics like Job Size, Job Complexity, Effort or Ease.

There are 2 ways we could go about connecting the Jira story points field to Foxly, to include it in your prioritization formula. We can use exact story point value in the scoring formula or we can map story point values to our Effort metric and keep using labels in Foxly (eg. t-shirt size estimation: S, M, L).

Option 1: Using the exact story point value

Let’s have a look at an automation rule example that fills values of the Story Points metric in Foxly when the Story point field in Jira changes.

Changes in Foxly

  1. In Foxly, create a new numeric metric called “Story points” for example, and check the option to store value in a custom field.
  2. Include field in your scoring formula; if you’re using one of the predefined templates like RICE or WSJF, you can just replace the “Effort” or “Job size” metrics in your formula.

Setting up the automation rule

  1. In your project, go to Project Settings > Automation (or in team-managed projects Project settings > Apps > Project automation) and create a new automation rule
  2. As an automation trigger, set Issue created and Issue updated
  3. And as a new action, select the Edit issue and click on More options then add the following JSON in the Additional fields:
{
"fields": 
    {
    "Story Points - RICE Value":{{{issue.Story points}}}
    }
}

Keep in mind that story point fields are named differently in company-managed (former Classic) and team-managed (former Next-gen) projects:

  • {{{issue.Story Points}}} - Returns the issue's story point estimate (company-managed only).
  • {{{issue.Story Points estimate}}} - Returns the issue's story point estimate (team-managed only).

Every time someone updates the Story point field in Jira Automation, Jira updates your Foxly metric as well, which is then factored into your Priority score.

If you also want to automatically fill the Story point field in Jira when someone sets a metric in Foxly, then you can use the following rule👇

  1. In automation for Jira create a new rule and as a trigger set Field value changed
  2. Select a Story points - RICE Value field in Fields to monitor for changes dropdown
  3. And finally, as a New action set Edit issue, set a Jira Story points field as a field that should be updated with {{issue.Story Points - RICE Value}}

Option 2: Mapping story point values to label metric

If you like a label style of metrics in Foxly and you want to keep using them, you can map which story point values correspond to which label.

For example, let’s say that your team is using the following values of story points for estimation 0.5, 1, 2, 3, 5, 8, 13, 21, then you can map them to your effort label as follows:

Label Mapped story point value
XS <2
S >=2 & < 5
M >=5 & < 13
L >=13 & < 21
XL >=21

The automation for this will then look like this:

  1. A trigger is Field value changed and the field that triggers the change is Story points
  2. Then use the Branch rule so we can update a Foxly effort field with the right value, only when it matches the right condition
  3. To assign S label to the Effort metric in Foxly, use JQL condition

"Story points" >= "2" AND "Story points" < "5"

4. Then set an action to update the Effort field in Foxly

{
"fields": 
    {
    "Effort - RICE Label": S
    }
}

5. Create a branch rule for each of your labels and change JQL conditions accordingly

You can of course do this in the opposite direction, filling the Story points field every time someone updates the Effort metric in Foxly.

[Picture here on how this automation looks Foxly <> Jira]

2. How to automatically discount the score of flagged (or blocked) issues 🚩

It might happen that you have issues in your backlog with a high score but they’re marked as flagged because they’re being blocked by issues that have a much lower priority score. If that’s the case, you can consider adding the “Blocked” metric into your score formula and connecting it to the flagged issue feature in Jira.

For example, if you’re using a simple ICE method, you can create an extra label metric “Blocked” with values YES (0.5) and NO (1) and adjust the scoring formula to Impact*Confidence*Effort*Blocked. This way the issue that is being blocked gets its score discounted by 50%.

Then we’ll create an automation rule in Automation for Jira where:

  1. The trigger is Field value changes and the selected field is Flagged
  2. Then create a branch rule with an Issue field condition where we check if Field flagged is empty.
  3. For this condition create an action Edit issue and in More options, add the following JSON:
{
 "fields": 
    {
    "Blocked - RICE Value": 1
    }
}

4. Create another branch rule with an Issue field condition where we check if Field flagged is not empty.

5. And finally for this condition, create an action Edit issue and in More options, add the following JSON:

{
 "fields": 
    {
    "Blocked - RICE Value": 0.5
    }
}

You can also create an automation rule to flag and unflag an issue in Jira when someone changes the Blocked metric in Foxly; you can watch the video in the beginning of the article to see how to do that.

3. How to add a number of linked blocked tickets to affect the score ⛔️

You can also consider the number of linked tickets to the issue you’re prioritizing. You can go even further and specify a certain number of “is blocked by” links for example, so that tickets which are blocking others are prioritized higher.

Let’s have a look at how you could set up a rule like this:

  1. In Foxly, go to Customize and create a new numeric type of metric named for example "Blocking"
  2. Add a new metric in the scoring formula and save changes to the template
  3. Then go to Settings > Automation and create a new automation rule where the trigger is Issue linked and the type of relationship is Blocks
  4. Now we’ll create branches for a current issue and linked issue. A linked issue branch will have the following steps
  5. For a linked issue branch, select link type Blocks

a. Now, create new action Lookup issues and add the following JQL:

issue in linkedIssues({{destinationIssue.key}}) and issueLinkType = "blocks"

b. And then create another action “Edit issue” and in More options, add the following JSON:

{
"fields": 
    {
    "Blocking - [Template name] Value": {{lookupIssues.size}}
    }
}

6. A current issue branch has the following steps:

a. Create a new action “Lookup issues” and add the following JQL:

issue in linkedIssues({{issue.key}}) and issueLinkType = "blocks"

b. And then create another action Edit issue and in More options, add the following JSON:

{
"fields": 
    {
    "Blocking - [Template name] Value": {{lookupIssues.size}}
    }
}

Once you save and enable this rule, a number of issue-blocking tickets will be reflected in the “Blocking” metric and the priority score as well.

4. How to consider data from 3rd party apps in your prioritization 🔌

If you’re using tools like Intercom or Freshdesk that give you insight on how many times a certain feedback was raised, it might be useful to apply this data into the prioritization formula.

First, you need to make sure that the number from the 3rd party app you’re planning to use is stored in a custom field in Jira. Then you can connect it with the Foxly metric using Automation for Jira.

Here is a step-by-step on how to do that:

  1. Make sure that the 3rd party app stores the info in a custom field (follow their documentation on how to do that)
  2. In Foxly, go to Customize and create a new numeric metric (eg. “Intercom-requests”) and select the option to store the metric in a custom field
  3. Add a newly created metric to your scoring formula and save changes to the template
  4. In the Automation for Jira, create a new rule where the trigger happens when the Issue field changes
  5. As an action, set Edit issue and select More options then add the following JSON:
{
"fields": 
    {
    "Intercom-requests - [Template name] Value": {{issue.Custom field name}}
    }
}

When a 3rd party field is updated for example, another support request from Intercom is linked to the ticket; Foxly metrics will then update, together with the priority score. Using these steps, you can connect Foxly metrics to any 3rd party app as long as the values are stored in Jira custom fields.

Enjoy making use of these cool automation rules; hopefully, they help improve your prioritization process. And for any questions or requests, please don't hesitate to get in touch with us through our support portal!


Further reading