A Jira issue represents a piece of work that needs to be done. Depending on the nature of that work, you can use a bug, story, task, or other relevant Jira issue type to categorize and describe it. Users define and arrange their work whichever way they want, based on the type of issue, the workflow it supports, and the information it conveys.
Still, there are instances where sophisticated Jira issues require too much time and effort to make them feasible. Or cases, where none of the available issue types can truly represent the project items you need.
Luckily, as a BigPicture user, you don’t need to worry about Jira issue customization or look for tedious workarounds. The app’s native, basic tasks can easily fill the utility void in Jira issues, so you can achieve more in a matter of minutes. No heavy customization, no unnecessary hassle.
What are basic tasks, how are they different from Jira issues, and how can you use them? That’s what you will learn from today’s post.
Jira issues and basic tasks
Jira issues and basic tasks have a few things in common, but they’re also different in some ways. The reason we introduced the basic task in BigPicture was not to replace Jira issues but to complement them. By having both, basic tasks and Jira issue types to choose from, you can be more flexible in how you plan to achieve your goals.
Basic task vs Jira issue: similarities
Similarly to Jira issues and their respective types, basic tasks represent different pieces of work — by summarizing instead of describing them. For that reason, you can treat them as placeholders for a certain piece of work, then later categorize and describe them by converting them to tasks, user stories, or other Jira issues.
Even without the conversion, you can utilize a basic task the way you would a Jira issue. In particular, you can assign it to a resource, set a status, provide start and end dates, add a baseline, and estimate the effort required for completion (e.g., with hours or story points).
Moreover, basic tasks can serve as subtasks, and allow you to build parent-child relationships between several basic tasks, Jira issues, or both. And since either of them can be a parent or a child, basic tasks also follow all of the scheduling modes (formerly “period modes”) available in BigPicture.
Another important feature of basic tasks is that you can build strong dependency links between them, according to the available dependency rules (e.g. Start to Finish). However, since basic tasks do not use Jira fields but BigPicture fields, dependencies between basic tasks will not auto-synchronize.
To sum things up, basic tasks can fulfill the same functions typical to Jira issues, and exist in your project structure. But what about the differences?
Basic task vs Jira issue: differences
In essence, a basic task — as the name suggests — is very basic. It features only three mandatory fields: “Summary,” “Start date,” and “End date.” Although your Jira admin could configure a Jira issue to contain a few Jira fields only, such a setup would apply solely to a specific issue type (e.g., a bug) within a specific project. In other words, they would need to manually customize an issue from scratch, then assign it to the applicable project(s).
However, with a basic task, you don’t need an admin to customize things for you. You get a simple task right out of the box, that you can create with very little effort and time. Please keep in mind, however, that basic tasks do not categorize work items like Jira issue types do, since there are no different basic task types.
But it doesn’t make it a drawback; on the contrary — it is by design. Thanks to the “Summary” field alone, you can use basic tasks to fulfill various roles (which we will explore later in this article). You can also turn a basic task into a milestone by simply toggling the “Create as a milestone” option.
The most important difference between a basic task and Jira issue is related to the lack of synchronization between BigPicture and Jira (and other connected platforms). The reason for it is that basic tasks live in BigPicture only. It means that you cannot bi-directionally sync basic tasks with Jira or create them in Jira.
So why would you want to waste your time on tasks you cannot even view in Jira? In fact, basic tasks have quite a few, very practical use cases.
Basic tasks in action: use cases
We mentioned that basic tasks can represent any work item, and have an assignee, description, estimate, and duration. But basic tasks are more than just “work to do” and you’re about to find out how else you can use them.
When you want to quickly prototype your project plan on a Gantt chart without getting into creating real tasks, you can do so with basic tasks. They are more than enough to let you build a structure however you want it. And since you can also assign specific start and end dates, and draw dependencies between them, your lightweight plan will give you just about the right idea on how to proceed with your real plan.
Custom project hierarchies
Basic tasks are fast to create, and they obey the same relationship and scheduling rules. So, instead of going through the Jira issue customization process (or creating a custom type from scratch), you can use basic tasks to quickly build a structure for your project — or an initial template for your upcoming initiative.
You can start off with the high-level hierarchy by adding parent basic tasks. Then, gradually increase granularity by hooking up more basic tasks or Jira issues.
When creating your hierarchy, you might not exactly know what every basic task will represent in the future. Maybe it will be a milestone, a project phase, or an Epic. For now, you have a convenient placeholder you can later convert to a milestone or any issue type you wish.
You can group basic tasks into task templates (a series of ready-made tasks). For example, you can add several tasks to a template, then plug that template into your existing project. This way, you will be able to add multiple subtasks to a selected parent on your Work Breakdown Structure (WBS) or add multiple parents and associate subtasks with them.
“Special type” of work
Basic tasks can stand for work you have assigned to another team, or a job you coordinate using another tool/software. You can also use them to mark a component of your project — which is to be delivered by a contractor or outsourced team.
Custom task levels (hierarchy)
If you manage a Classic or Hybrid project, you may need to break it down into consecutive phases or stages — which are absent in Jira (unless your admin creates a custom issue type for you). If your project only has a few phases, it might be much easier and quicker for you to create basic tasks and name them, “Stage 1,” “Stage 2,” and “Stage 3” for example.
In our example above, a basic task, as a phase, can be the most overarching item to group a cluster of other basic tasks and Jira issues (including an Epic).
We just mentioned that basic tasks can sit at any level in your hierarchy, and as parents, they can hold any number of children together. But there is more to it — since they have the capability to be the highest-level items, they can also aggregate subtask data.
So, if you want to sum up and track project costs, as well as time and effort estimates for your tasks, hook them up under the basic task. Then, add the columns with the data you wish to track (be it with respect to time, cost, or effort for example) and choose the aggregation method. This way, you will be able to track the overall progress of your project, individual phases, or any chosen group of tasks.
Sprints on a Gantt chart
You can also use basic tasks to create sprints on a Gantt chart. In this case, basic tasks will stand for individual sprints (or iterations) and group user stories, as well as tasks that you have planned for the respective sprint. The bottom line is, basic tasks can group and overarch any combination of tasks and issues.
If there is some important event coming up, somewhere along the project, or you simply wish to remember something, turn a basic task into a tiny notepad. Simply leave a note for yourself (or other stakeholders) in the “Summary” of the basic task. Be concise as there is no place for a description.
Afterward, you can move it to the right place in your project. And if you want to make sure you don’t forget, add a marker to your Gantt timeline or Agile Board.
Alternatively, a milestone can serve the same purpose, so you can pick either.
How to create and convert a basic task
Similarly to Jira issues, you can in-line create basic tasks directly onto the project structure (in Scope, Gantt modules), or by choosing an option from the upper menu (in Scope, Gantt, Resources modules, and on the WBS widget). When your basic tasks are in place, you will also be able to see them in the backlog and board (in the Board module) even if you cannot create them there.
Creating basic tasks
To create a basic task, navigate to the “+” button in the upper left corner of the app menu (for example, in the Scope module). Alternatively, hover over the swim lane on your WBS to prompt the “+” button. Click it and select “Create task > Basic task.”
Next, provide a description in the Summary field, based on the purpose of the task (e.g., a quick note). Once your task is in place, select it then click on the “+” in the upper menu to create a subtask.
Converting basic tasks to Jira issues
If at any point in your project lifecycle, you realize that you need to have Jira issues instead of tasks native to BigPicture, you can then convert basic tasks with just two clicks.
Find the basic task you wish to convert, then right-click and select “Convert to Jira issue.”
Please note, that once you have converted a basic task into a Jira issue, you cannot go back.
Basic tasks: simple yet powerful
To summarize, you can use basic tasks in a variety of ways. Most notably, basic tasks are convenient placeholders for items you have not defined yet. They can also hold additional notes and reminders for you and your stakeholders. And finally, they can parent any group of work or project items, on any level, allowing you to easily create custom hierarchies and aggregate data of the subtasks.
Their simplicity is their strength. What other interesting ways will you come up with to make them part of your project?