Category: Content

Now that you know why good form design is important and how to ask good questions, here are some quick ways to improve Jira screens and Jira Service Desk request forms.

Jira

Use these easy field tips in Jira.

1. Limit fields on the Create screen

When you create a project, Jira automatically creates screens and schemes for it. A “Kanban Default Issue Screen” includes 14 fields! By the time you’ve added additional custom fields, screens are often long and cumbersome. Just because info is needed, doesn’t mean it’s needed at the same time the issue is created. Group your fields into the following categories:

• information needed immediately (Ex: Description and Requested date),
• information needed later in the workflow (Ex: Estimate and Due date),
• and information needed before an issue is completed (Ex: Time tracking and Root Cause).

Only show fields in the first category on the “Create” screen. Fewer fields make issues easier to create, especially for non-technical users.

Also only ask for information the creator can immediately provide. For example, if the creator isn’t the person who calculates the estimate or determines the release date, omit those fields. You can collect that information, during a scheduling process, later in the workflow.

If you have “Edit” and “View” screens, include all the relevant fields, so info is easy to update at any time. Usually these actions can share the same screen but sometimes they are different.  Example:  A field has a value but editing it is not desired.  In this case, the “View” screen shows the field but the “Edit” screen does not.  As a reminder, for Jira Cloud Next-gen projects, there’s just one screen per project or per issue type and no distinction between the create, edit, and view operations.  

2. Use tabs to group similar fields

If there are many fields, use the “tabs” feature to group them. In the screenshot, all user picker fields are together in the “People” tab and all date and version fields are in the “Internal” tab.

3. Collect additional information during the workflow

Determine when in the workflow other fields should be completed. For example, fields like “Assignee”, “Due date”, and “Original Estimate” should be filled before an issue reaches the “In Progress” status. Use a workflow transition screen, and validators, to require entry. If you’re using ProForma, you can create separate forms to collect information at different times in the workflow.

4. Order fields strategically

List fields in the order the user is likely to supply the information. Place more important fields at the top.

Always place the “Priority” field before a “Requested” date field.  It may help set realistic expectations to ask for the importance before the date.

5. Order fields consistently

Use a consistent field order for all issue types and projects. Users expect and appreciate a standard.

6. Only create fields that are reported on

Don’t show unnecessary fields, collect information you won’t use, or create custom fields that aren’t queried. Instead, use the standard “Description” and “Comment” fields and train users what information to provide.

7. Utilize best practices and standard web form conventions

When creating screens, be aware of the web and application standard conventions that users expect. Here are some tips for effective and useful web forms.

• Don’t ask too many questions
  Only ask for information you’ll use.  For example, if you plan to respond to issues via email, only ask for an email address (not an email address, a phone number, and a mailing address.)  If you already have the reporter’s email address on file, don’t ask them to type it. Short web forms are more likely to be completed.  Users dislike providing many ways for you to contact (aka spam, annoy) them.
• Ask specific questions
  Use field descriptions to ask the user for specific information or to provide formatting instructions.  Asking a specific question gives you better information than a blank or “Enter your message here” description.  Examples: “What software do you need installed?” or “What is the expected result of the defect?” 
• If a field has validation requirements, tell the user exactly what to enter
  Give clear and easy to understand directions.  Don’t wait for a user to enter data incorrectly before providing them with formatting instructions.  For example, tell the user to enter their phone number in the format: ###-###-#### rather than provide the vague error “Please enter a valid phone number.”
• Confirm successful submissions
  After a user clicks the submit button, there should be a confirmation that the message was received or an error message if there were any problems. Jira handles this functionality by default.
• Post and adhere to your privacy policy
  Any time you collect user information, you should have an easily accessible privacy statement that addresses what you collect, how you use it, and under what circumstances, if any, you disclose it.  If completing a form means you’ll add their email address to your newsletter system, for example, that needs to be clear.  This is important for public instances and when you use Jira for customer support.
• Consider your audience
  As with everything web related, create forms with the end user and their specific goals in mind.  You may need separate forms for existing customers, new prospects, or different situations.  Don’t try to serve all users and all conditions with the same form.

Jira Service Desk

With Jira Service Desk, you have a different audience to consider.  In Jira, the create form should be as short as possible.  But in Jira Service Desk, it’s important to collect all the important details up front, to avoid multiple rounds of follow-up questions.  This is especially important when working with external customers in different time zones.

Use the Jira tips above and these additional tips for JSD.

1. Use “Introduction text” to provide portal instructions

Enter a custom message to help users understand support options and share additional help resources. The intro message is especially important when there are multiple Service Desk portals. Intro message space is available in addition to the temporary announcement banner. (Both are pictured below.) Visit Project Settings > Portal settings to enter introduction text.

2. Use the “Description” field to help users select the correct form

Add a short description for each request form, so users can determine the best selection for their request.

Always provide a selection for “all other requests”. In the screenshot above, there’s a generic form titled “Get IT help.”

3. Use the “Help and instructions” field to set request expectations

Enter custom instructions for each request form so users know what information is needed and how long it usually takes to receive a response. In the screenshot below, the user can expect help within 2 hours for this type of support request.

4. Customize field labels and add field descriptions

In JSD you can customize a Jira field’s label. For example, I often change the default “Summary” label to the more descriptive “Summarize the problem.”

Similarly, you can also customize field descriptions. Use the Jira field description for Jira users and tailor language in the Portal to that audience.

5. Group forms by request type

In my former role as a web developer, I always considered a user’s capacity for processing information. Too many form choices can overwhelm a user. If you have more than 5 request forms, use the JSD “groups” feature to categorize the list.

6. Use unique form icons

Each request form has an icon. Make each unique and choose icons that visually communicate what each request form is for. If you can’t find the right icon, you can make your own. Atlassian recommends a 20px grid with 24px padding. Read more

Finally, and most importantly, make it easy, intuitive, and painless to complete Jira screens and Jira Service Desk request forms.  The process should be simple for all users.

OTHER ARTICLES IN THIS SERIES:

• Why Form Design in Jira Matters  –  How you design your forms will impact the quality of data you receive, and much more!
  
• Layout and Flow: Creating User-Friendly Forms in Jira – Form layout affects completion rates and user frustration. We’ll discuss the right way to do it.
  
• Writing Good Form Questions in Jira: Part 1 – How do you choose the right words, field types and validation levels? This article will dig into the nitty gritty of creating good form questions. 
• Writing Good Form Questions in Jira: Part 2 – Choice questions are great for collecting structured data. We’ll look at the options for choice questions and discuss ways to influence, or mitigated influence on the user.
• Things to think about when converting forms in Jira – Bringing a process into Jira for the first time? Don’t just copy forms straight across. This is a chance to make improvements.
  
• Efficient Jira Screens and Jira Service Desk Request Forms – Jira screens and JSD request forms aren’t the same. Here’s how you can make each one work for its audience.
• Tips for Creating good forms/screens in Jira – Learn how you can leverage Jira features like tabs, workflow transitions and icons to create better forms and screens.

When I became a Jira administrator, the most confusing part of project administration was how screens, screen schemes, and issue type screen schemes worked together. Huh? All I wanted to do was to change a few fields around and instead, I found myself lost in a confusing combination of settings that didn’t make any sense to me. Shouldn’t it be easier? Once I understood the relationship however, I saw how powerful these settings are when they work together. Let’s start out with some simple definitions.

Screens

Screens define which fields are present and their display order. Jira Server and Jira Cloud “Classic” projects have four types of screens. They are:

1. Create: A screen for creating a new issue
   • This screen collects the initial information from the Reporter. It often contains just a few of the most important and required fields.
2. Edit: A screen for editing an existing issue
   • This screen contains all the fields a user is able to complete or update.
3. View: A screen for viewing an issue’s details
   • This screen contains all the fields a user is able to view.
   • Note: Jira Server and Jira Cloud “Classic” projects only display fields that have data. For example, if the “Due Date” field is empty, you won’t see it on an issue’s view screen.
4. Transition: A screen that is displayed during a workflow transition
   • This screen is often used to collect or update data at different points in an issue’s lifecycle. For example, the “Resolution” field value is collected before an issue reaches its final workflow status.
   • Tip: Distinguish your transition screens from other screens by naming them with a “(T)”. Example screen name: Assignment (T). See screenshot.

You can have one screen, or one set of screens, for all issues in your project. Or you can have different screens for each issue type. We’ll talk more about that in the “Issue Type Screen Scheme” section below.

Jira Cloud “Next-gen” projects work differently however. There’s just one screen per project or per issue type and no distinction between the create, edit, and view operations. “Next-gen” projects treat empty fields differently as well. An empty field displays with the word “None” below it, as pictured.

Fields and Ordering

In all versions of Jira, screens display both standard and custom fields.
Some fields can be ordered as desired by rearranging them on the admin view of the screen.  Other fields are automatically placed and grouped together. For example, all user-picker fields (“Assignee”, “Reporter”, etc) appear together on the right side of an issue’s screen. All date fields (“Due Date”, “Created Date”, “Updated Date”) also appear together on the right.

Screen Schemes

Jira Server and Jira Cloud “Classic” projects have Screen Schemes.
Remember the “create”, “edit”, and “view” operations above? This scheme associates one or more screens with an operation.

In this simple example, there’s one screen for each operation.

In this more complex example, there is one screen for the “create” operation and another screen for the “edit” and “view” operations.

A Screen Scheme can have as little as one screen shared by all operations or as many as three screens, with one screen for each operation.

Why Multiple Screens?

I recommend starting with one screen shared by the “create”, “edit”, and “view” operations in your project. If that screen becomes cluttered with too many fields, or if information needs to be collected during different stages of the workflow, then consider using multiple screens.

Issue Type Screen Schemes

Jira Server and Jira Cloud “classic” projects also have one final setting called an Issue Type Screen Scheme. This scheme associates screens with different issue types. Just like you can have different screens for different operations, you can have one set of screens for your Bugs, one set for your Stories, and another set for your Tasks.

This Issue Type Screen Scheme has two Screen Schemes. The Bug issue type uses the “Bug Screen Scheme” which has two screens. The Epic issue type uses the “Epic Screen Scheme” which has one screen.

Tying it Together

Screens, Screen Schemes, and Issue Type Screen Schemes work together to power your project. Atlassian explains this relationship in this diagram.

It look me a long time to understand these concepts. I recommend you re-read this article and experiment in your own Jira test environment, until the relationship between these settings is clear.

Jira Service Desk Request Forms

If you have Jira Service Desk, there’s another type of “screen” to be aware of. When Service Desk Agents login to Jira, they see the typical Jira screens described above. When Service Desk Customers login to the Customer Portal however, they see request forms.

Request forms provide a simpler and streamlined issue view, which is great for less technical audiences. Customers need no Jira knowledge to use the portal to submit their request.

In the example below, the left image shows a default Jira create screen, which contains 21 fields. The right image shows a default Jira Service Desk change request form, which contains only 10 fields. Which one looks easier to complete?

Best Practices

Make your screens and schemes as easy, efficient, and reusable as possible. Here are some recommendations:

As With all Forms

• Don’t collect data you won’t query on or actually use
• List fields in the order a user would likely supply the information
• Order fields consistently between issues types in a project and between projects. Users expect and appreciate a standard.
  • Example: The “Summary” field is always first, the “Description” field is always second, etc.

For Jira Server and Jira Cloud “Classic” Projects

• Use a single screen for all operations (“create”, “edit”, “view”) until there’s a real need for additional screens.
  • Consider additional screens when there are too many fields or if information needs to be collected during different stages of the workflow.
• On the “create” screen:
  • Only include the most important and required fields. Too many fields overwhelm users. Too many fields also impacts loading and performance.
  • Only include fields relevant to the Reporter. For example, if a business team member is reporting a Bug, they can’t provide an effort estimate and won’t know which code version is impacted. Don’t show the “Story Points”, “Original Estimate” or “Affects Version” fields. Instead, add these fields to your “edit” and “view” screens. You can also prompt a development team member for that information, later in the workflow, using a “transition” screen.
• Create a single screen and a single screen scheme, for all issue types, until more are needed.
  • Example: You want the custom fields “Steps to Reproduce” and “Expected Result” on a Bug’s “create” screen, but not on a Story’s “create” screen.
  • Example: Create one standard for all development projects and another standard for support projects, not one custom configuration per Jira project.
• Create generic screens and schemes so they can be shared between projects.

Other articles in this series:

• Why Form Design in Jira Matters  –  How you design your forms will impact the quality of data you receive, and much more!
  
• Layout and Flow: Creating User-Friendly Forms in Jira – Form layout affects completion rates and user frustration. We’ll discuss the right way to do it.
  
• Writing Good Form Questions in Jira: Part 1 – How do you choose the right words, field types and validation levels? This article will dig into the nitty gritty of creating good form questions. 
• Writing Good Form Questions in Jira: Part 2 – Choice questions are great for collecting structured data. We’ll look at the options for choice questions and discuss ways to influence, or mitigated influence on the user.
• Things to think about when converting forms in Jira – Bringing a process into Jira for the first time? Don’t just copy forms straight across. This is a chance to make improvements.
  
• Efficient Jira Screens and Jira Service Desk Request Forms – Jira screens and JSD request forms aren’t the same. Here’s how you can make each one work for its audience.
• Tips for Creating good forms/screens in Jira – Learn how you can leverage Jira features like tabs, workflow transitions and icons to create better forms and screens.

The first time I converted a paper form to an online form, I made my online form a perfect replica of its predecessor. I figured the team I was building the form for would appreciate my being faithful to their original and I wanted them to feel reassured that the transition to digital did not mean they had to abandon their processes.

Later I learned that there are several reasons you shouldn’t do that:

• The form may not have been well designed in the first place.
• Processes may have changed since the form was last updated.
• Online forms allow us to use functionality that isn’t available for paper or PDF forms. We can make forms that are better for both the team that owns the form, and their customers/users.

Where to Start When Converting to Jira Forms/Screens

Instead of copying, gather the stakeholders and start from a blank slate. There are several things you should consider before creating your form:

• Define the user
  Who is the customer/user who will be filling out the form? What are they trying to achieve? Is there information that you’ll be asking for that the customer may not know how to find? Or information that they may not want to provide? Are there parts of the current form that customers frequently get wrong? What do you know about your users language level (Are you creating the form in their native language? Are you using technical terms or jargon they may not be familiar with?) 
  
• Decide what information you need to collect
  List the data points that need to be collected. Be willing to challenge the status quo. Since one of the principles of well-designed forms is minimalism, put every element (section, question, instruction) on trial for its life. If no one can justify why the data is needed, then ditch the question. 
  
• Note which data points need to be collected from which users
  There’s a good chance that you don’t need to ask every user every question. Note which questions are associated with certain scenarios. You’ll use this information later to make some questions conditional, thereby making the form shorter and easier for users.
  
• Decide when and where to place instructions
  Large blocks of text are annoying and often ignored by users. Move as much instruction as possible to the field level.
  
• Identify validation and formatting needs
  Get clarity on what’s required and what’s optional. Find out if there are any business rules (choice options, spending limits, etc.) that should be built into the form. Also, find out if there are preferred formats for text fields. Consider whether any of the fields should have a default value.
  
• Isolate the data points that will be queried/reported on
  While you’re still with the form’s stakeholders, find out which of the information points identified in step 2 will be used in queries and reports. Many data points are collected in order to provide a service, but are never queried. Sorting your data points into to camps will help you select the right field types and keep from creating unnecessary Jira custom fields.
  
• Locate the form in the business process
  Where does the form fit in the workflow? Are there circumstance where the form should be automatically added to the issue? What should happen once the form is submitted? Is the form part of a compliance strategy?

Create Your Form/Screen in Jira

Now you’re ready to create you screen/form. Remember to:

• Follow the rules of layout and flow to create a user-friendly form.
  
• Avoid creating new Jira custom fields unless absolutely necessary.
  Be judicious about creating new Jira custom fields. An over-abundance of custom fields makes your Jira configuration complex and will eventually degrade Jira performance.  A new custom fields should not be created unless it:
  • Can be used by multiple projects
  • Will be queried and reported on
  • Does not duplicate Jira functionality or an existing custom field

Try to use other options such as a ProForma field, a field configuration, or a field context.

• Make the most of the functionality offered by online forms.
  • Use conditional logic to ensure that users only see relevant questions
    
  • Build in validation and formatting to ensure clean, complete data
    
  • Use automation (either JSD’s or ProForma’s) to integrate the form into the larger workflow

By engaging in a careful discovery process and employing the rules of good form design, you can help teams maximize usability and efficiency as they bring their processes into Jira.

Other articles in this series:

• Why Form Design in Jira Matters  –  How you design your forms will impact the quality of data you receive, and much more!
  
• Layout and Flow: Creating User-Friendly Forms in Jira – Form layout affects completion rates and user frustration. We’ll discuss the right way to do it.
  
• Writing Good Form Questions in Jira: Part 1 – How do you choose the right words, field types and validation levels? This article will dig into the nitty gritty of creating good form questions. 
• Writing Good Form Questions in Jira: Part 2 – Choice questions are great for collecting structured data. We’ll look at the options for choice questions and discuss ways to influence, or mitigated influence on the user.
• Things to think about when converting forms in Jira – Bringing a process into Jira for the first time? Don’t just copy forms straight across. This is a chance to make improvements.
  
• Efficient Jira Screens and Jira Service Desk Request Forms – Jira screens and JSD request forms aren’t the same. Here’s how you can make each one work for its audience.
• Tips for Creating good forms/screens in Jira – Learn how you can leverage Jira features like tabs, workflow transitions and icons to create better forms and screens.

Questions and input fields are the heart of every form. In the previous article, we started digging in on the do’s and don’ts of creating good form questions. Now we’re going to take a closer look at a particular set of field types – choice questions.

The Power of Choice

There’s a lot to be said for choice questions. Choosing from a predetermined set of options is fast for the user. They don’t have to imagine what the possible answers might be, and they don’t have to spend their time typing.

If choice questions are good for the user, they’re awesome for the form owner and the database. They provide structured data that’s easy to aggregate, analyze and report on. They can also be used to trigger automation or conditional logic. As always, think about why you’re asking the question as you decide on field types, wording, and context.

Field Types for Choice Questions in Jira

There are multiple options for creating choice questions: Jira offers:

• Checkboxes
• Radio buttons
• Select lists (single, multiple and cascading)
• Picker fields (date, date and time, group(s), project, user(s), version(s).

ProForma includes:

• Check boxes,
• Radio buttons
• Dropdown boxes
• Pickers (date, time, date and time and user(s); ProForma also lets you create your own user picker fields by creating data connections that populate choice lists from an external source.
  

Determining which field type to use should be based on:

• Whether you want users to select one option only (radio buttons, dropdown, single choice select list), or more than one option (checkboxes, multiple choice select lists).
  
• Layout and available space on the form/screen – Radio buttons and checkboxes are fastest for users because they can see all of the choices at once, no extra clicks required. However, if you’re option list is excessively long, dropdown boxes let you save space on the screen.

Since choice questions already limit the user, when choosing field types it’s good practice to use the least restrictive option. Radio buttons, single select lists and dropdown boxes mean the user can only select one option. If there’s any possibility that the user would want to select more than one option, use check boxes or a multiple select list.

Things to Consider When Creating Choice Questions

• Make Sure Everyone Can Respond
  The limitation of choice questions, is that they are closed.  While this may be helpful to the form owner, it can be frustrating for the user. What if what they really want to choose isn’t listed as an option? One advantage of using ProForma is that it allows you to include an “Other” option, with an adjoining text field on your choice lists. Depending on how your question is phrased, it may be appropriate to offer options such as “I don’t know,” or “Not applicable”. The important thing is to make sure that your choices offer every user the opportunity to provide an honest answer.
  
• Structure Your Rating Scales
  Choice questions are often formatted as rating scales (strongly agree > strongly disagree, etc.) to measure user’s opinions or satisfaction. Carefully consider if you want an even or odd number of options. An odd number of options gives the user a chance to be neutral, while an even number forces them to give an opinion. (If you’re not going to make the user give you an opinion, is it really worth including the question?)
  • Label each point in your scale with words, so users don’t have to take the extra mental step of translating numbers into another meaning. Scales should not be too large, and the increment (in meaning) between each point on a scale should be equal.
  • Points on a rating scale can either go from “lowest” to “highest” or vice versa. Scales are frequently structured with the most positive response listed first because users ofter select the first option they see. The important thing is to be consistent throughout your form.
    
• Avoid Double-Barreled Questions
  Since the purpose of a form is to obtain structured data, it’s important that each question asks only one thing. This is especially true for choice questions. Otherwise, you’ll end up with a bunch of easy-to-categorize answers and have no idea what they refer to. Customer satisfaction surveys that ask you to agree or disagree with statements like, “The agent I spoke to was friendly and knowledgeable,“  miss the mark. What if the agent I spoke to was kind, but clueless?
  
• When a Choice Really Isn’t a Choice
  Sometimes we use choice questions when we’re really not offering the user a choice. The user has to say yes if they want to continue the process. In these cases, a checkbox is the correct field type since we are not excluding other options. In a previous article, I said that if you want users to read your instructions, you should avoid big blocks of text. The opposite is also true: If you want your users not to read something, make it long and full of jargon. John Oliver does a great job of describing how effective this is.

Choice Architecture

As with all form questions, you’ll want to use concise and unambiguous language. But creating good choice questions requires additional considerations. How you frame your questions can impact how users respond. This is called choice architecture. You may want to use it your advantage, or you may want to try to limit your influence to get a more “pure” response from your users. 

The Influence of Defaults

One of the first decisions you’ll need to make is whether or not to include defaults. Defaults save time for the user. They also nudge the user in a certain direction. Users may perceive the default options as being recommended (after all, that’s what everyone else is choosing). In some cases, the default option may even be labeled as recommended. Even when logic doesn’t tell us to leave the default, inertia often does. We’re happy to avoid making a decision.

The most frequently cited examples of this mechanism at work are the differences in organ donation rates (cited in the first article of this series) add image and the use of “opting in” to get employees to contribute to retirement savings account. Parting with your organs, or your money, is a serious decision. Yet the evidence shows that many of us are happy to simply follow the default’s lead.

If you feel really confident that you know what the vast majority of users would want, use a default. If you want to encourage your users to make a certain choice, use a default. If you want to get more impartial data from your users, don’t use a default. Be cautious about offering a default for a required field. If the field is important enough to be required, you probably want your users to consider their answers, which they are less likely to do if a default is provided. 

Choice Order Changes Results

Even if you don’t use a default, some bias will be built into your choice questions simply because you have to list the options in some kind of order. Inundated with information, our brains have learned to scan, which means we’ll pay more attention to the first and the last item in a list.  In most cases, it’s sufficient to just put your choice options in some kind of logical order (lowest to highest, alphabetical, etc.). This makes it easy for the user to find the option they’re looking for. However, if you want to truly minimize the influence of the first/last bias, you need to randomize your choice options.

How Framing & Decoy Affects Impact Responses

How your question is perceived will be impacted by the words you choose. Here’s a example that frequently comes up when buying an airline ticket:

The words have been chosen carefully. Including the price of the flight reminds the user of the investment they’ve already made and makes the price of the insurance seem insignificant by comparison. The word “risk” also pushes the users towards buying the insurance.

In addition to wording, visual cues can be used to nudge a user to a certain choice.  Here’s an example from Atlassian.

The Cloud option has an eye-catching button, while Server is a simple text link. Cloud is also the option on the left, where we usually find buttons like Save and Publish, as opposed to the right where we often see Cancel.

Another common practice is to make an item seem more appealing in comparison with the other choices on the list. This strategy is commonly seen on eCommerce sites.  Personali™ offers this example from BestBuy.com.  Compared to the $1,000 camera, the $45 memory card seems cheap.  However, if the user were to search the site for memory cards, they’d find equivalent options at a much lower price.

It should be noted that, as with the examples of organ donation and employee retirement contributions, these kinds of strategies can be used for the user’s benefit, or – as with the examples from Best Buy and Atlassian – to push a product. The important thing is to be aware that when you create choice questions, you can (and frequently are) building in a bias. Therefore, you need to structure and word your choice questions carefully.

Conditional Logic

Along with being fast and easy for the user, and producing nice clean data for you, choice questions allow you to use conditional logic. Conditional logic allows you to dynamically show or hide form questions based on a user’s response to a previous question. This allows you to:

• Reduce cognitive overload for the user – the form looks less cluttered, less overwhelming.
• Shorten the user’s path to completion – the user only sees the parts of the form that are relevant to them. There’s no confusion about which parts they are supposed to fill out.
• Use one form for multiple, similar use cases.
• Accommodate edge cases.
  

Let’s look at a few examples.

An HR department is using Jira Service Desk to manage Personnel Action Notifications.

When the form first loads it looks like this:	Other questions appear depending on what items need to be changed.

Conditional logic is one of the biggest advantages electronic forms have over paper forms. It’s also one of the best things you can do to make your forms more user-friendly – especially customer-facing forms on the JSD portal.

The ability to create forms in Jira, without dozens of custom fields or complex configurations, makes Jira and JSD a viable options for non-tech teams.

In our next article, we’ll look at things you should consider when helping those teams (or any team) bring their existing forms into Jira.

• Why Form Design in Jira Matters  –  How you design your forms will impact the quality of data you receive, and much more!
  
• Layout and Flow: Creating User-Friendly Forms in Jira – Form layout affects completion rates and user frustration. We’ll discuss the right way to do it.
  
• Writing Good Form Questions in Jira: Part 1 – How do you choose the right words, field types and validation levels? This article will dig into the nitty gritty of creating good form questions. 
• Writing Good Form Questions in Jira: Part 2 – Choice questions are great for collecting structured data. We’ll look at the options for choice questions and discuss ways to influence, or mitigated influence on the user.
• Things to think about when converting forms in Jira – Bringing a process into Jira for the first time? Don’t just copy forms straight across. This is a chance to make improvements.
  
• Efficient Jira Screens and Jira Service Desk Request Forms – Jira screens and JSD request forms aren’t the same. Here’s how you can make each one work for its audience.
• Tips for Creating good forms/screens in Jira – Learn how you can leverage Jira features like tabs, workflow transitions and icons to create better forms and screens.

Questions, and the input fields that collect their answers, are the heart of every form. Getting your questions right, will mean getting your data right. Well designed questions also minimize frustration for the user. You’ll need to decide what field types to use, what context to provide, how to word your question and how much validation to include. Think about why you’re including each question. What data are you hoping to get? Then consider the user’s point of view. How should you create the question in order to make it easy for them to respond with the data you’re looking for?

Open vs Closed

Questions come in two general varieties, open and closed. Open questions (text fields) let the user type in what they want to tell you. Closed questions (check boxes, combo boxes, pickers and radio buttons, select lists) let the user choose an answer from options you provide.

They each have their advantages. Closed questions are good for users because they are easier to interpret and quick to fill out. They’re good for you because data comes into your database in nice categories, with consistent formatting. Data from closed questions is easy to aggregate and report on.

Open questions are more work for the user. They have to interpret what you’re asking, decide what they want to say, and then type it in.  However, open questions ensure that the user has a chance to say what they want to say. The user may be looking for an opportunity to tell you something you didn’t think to ask. While open questions don’t make for tidy reports, they allow users to provide information which can lead to disruption, innovation and continuous improvement. If your forms use purely closed questions, you may force the user and a service agent to comment back and forth in order to get important details.

Finding the right balance of open and closed questions will depend on the purpose of your form. Consider including at least one open question on your form. This could be an overview question up front – like the Description field in Jira – or an optional “Comments” field at the end. You can also mitigate the restrictiveness of closed questions by including an “Other” option. (We’ll dive deeper into closed questions in the next article.)

Asking Good Questions

Teachers are fond of saying that there’s no such thing as a stupid question. I beg to differ. Stupid questions are questions that don’t ask what you want to know, or questions that try to ask too many things at once.

Whenever I call my credit card company I immediately get a follow-up email that asks:

The first part of the question indicates that they want to know if I’m happy with the customer service I received, but the second part of the question asks something completely different. The question is either:

• Using the wrong metric to measure customer service;
• Or, trying to ask two different things at once.

Personally, I would never choose or recommend a credit card based solely on customer service. Other factors – interest rates, cash back and annual fees play a big role.  Since I’m middle-aged my friends and family members have already found credit cards that work for them. Giving an honest answer to the question might reflect badly on a perfectly competent agent who took my call. The result is that, unless I received really bad service, I don’t answer the question.

Resist the temptation to use double-barreled questions as a strategy for keeping your forms short. Yes, you want to be brief. That’s why you’re only asking questions you really need the answers to. But if you lump two questions into one, you won’t know which part the user is answering. The agent and the user will have to exchange comments back and forth to clarify, and you’ll end up taking up more of the user’s time than you would have if you’d just included two questions in the first place.

Language

How you word your questions matters.  Choosing unambiguous wording will mean reduced frustration for your users, and fewer errors in the data you receive. When writing form questions:

• Know your audience
  The language you use should fit your audience. If your form is for the general public, remember that not everyone has the same literacy level.  Use plain language – short sentences and everyday words.
  
  What if the general public isn’t your audience? Reading through postings in the Atlassian Community, I notice that many participants are highly technical, but may not be native English speakers. Writing for this audience, I might choose a longer, more formal word that has a latin root (thus recognizable to speakers of other latin-based languages) over a shorter, more common word. It’s all about who you’re creating the form for.
  
  
• Provide context
  Organizing your questions into logical sections will help provide context for the user. Depending on what you’re asking, that may or may not be enough context. Remember that the user doesn’t know what you know.
  
  Field level help text is a great opportunity to provide more context. Including an example can help the user understand what kind of response you’re looking for.
  

Rachel Wright provides examples on her Custom Workflow Documentation form.

If you’re asking a question that can seem intrusive, tell the user why you’re asking and how the data will be used. 

Finally, if you’re asking for information the user may not know how to find, help them out. For example, tell them where to find a version number for their software or a serial number for their hardware. You can put this information directly in your field help text, or use your help text to point to another page with detailed instructions.

• Use neutral words
  If you’re truly trying to get the user’s opinion, then strive for neutral wording. The words you choose can influence the answer, so avoid phrases that indicate what you think the correct answer should be. And if you’re wondering what leading questions look like, grab a political survey put out by a political party.
  
  You’ll also want to avoid using absolutes – words like all, always, never, etc.  Including an absolute means you will find the exceptions that prove the rules. You can improve your questions by simply deleting those words. 

Getting Text Fields Right

While text fields collect responses to “open” questions, that doesn’t mean that you don’t have any control of the data you receive. Using appropriate field types, formatting and validation will ensure you get data you can use, while still allowing users the flexibility they need. 

Field Size and Type

Text fields are not one size fits all. When choosing the size of your text fields (two options in Jira, three options in ProForma) remember that the size of the field should be proportional to the amount of text you want the user to input.

Text fields also come in many varieties. Along with various sizes (single line, multiple line/paragraph), there are also number fields, email fields, url fields, etc.  These fields have been formatted and validated behind the scenes to ensure that the user can only enter certain kinds of information. Using the correct field type means better data that can be used for other functions later (perform calculations with number questions, export a spreadsheet of email addresses to make a contact list, etc.).

Pattern Matching

You can also create your own text field types using ProForma’s Regex feature. Regex allows you to create text patterns that the user’s input must match.  These can be simple or complex expressions, and are a great way for collecting properly formatted data. Regex patterns are often used for collecting:

• Account numbers
• Phone numbers
• IP addresses
• Currency amounts
• References to ISO standards 
• Serial numbers

Note that you’ll want to tell your users what patterns the field accepts. Use field level help (the Description property in ProForma) to provide instructions and examples.

Validation

Finally, deploying validation rules – such as word/character limits and value limits for number fields – not only ensures clean data, it allows teams to build their business rules into their forms. As above, you can save time and frustration for your users by letting them know, either in the question itself or in the help text, what the limitations are.

Following the advice above will help make your text questions easier for your users to understand and respond to. However, chances are good that most of the fields on your forms will be choice questions, so we’ll look into the best practices for creating choice questions in the next article.

Other articles in this series:

• Why Form Design in Jira Matters  –  How you design your forms will impact the quality of data you receive, and much more!
  
• Layout and Flow: Creating User-Friendly Forms in Jira – Form layout affects completion rates and user frustration. We’ll discuss the right way to do it.
  
• Writing Good Form Questions in Jira: Part 1 – How do you choose the right words, field types and validation levels? This article will dig into the nitty gritty of creating good form questions. 
• Writing Good Form Questions in Jira: Part 2 – Choice questions are great for collecting structured data. We’ll look at the options for choice questions and discuss ways to influence, or mitigated influence on the user.
• Things to think about when converting forms in Jira – Bringing a process into Jira for the first time? Don’t just copy forms straight across. This is a chance to make improvements.
  
• Efficient Jira Screens and Jira Service Desk Request Forms – Jira screens and JSD request forms aren’t the same. Here’s how you can make each one work for its audience.
• Tips for Creating good forms/screens in Jira – Learn how you can leverage Jira features like tabs, workflow transitions and icons to create better forms and screens.