Should I pick STM or Deviniti's Issue Templates for Jira?

Pick STM if you want JQL-driven bulk create/update across many issues, cascading epic-to-story-to-sub-task templates, and an Update Templates feature for modifying issues that already exist. Pick Deviniti's Issue Templates if your workflow is centered on triggering sub-task/linked-issue creation from a specific workflow transition (its Create Structure post-function) or from the REST API, and you're comfortable with its repository-project model for storing templates.

Do both apps support sub-task templates?

Yes. STM treats sub-task hierarchies as a first-class template concept, including cascading templates that go epic to story to sub-task. Deviniti's Issue Templates copies sub-tasks from a template by default when a new issue is created from it, and its Smart Defaults feature controls which field values carry over (required fields always copy; optional fields copy only if added to scope).

How do the two apps store and organize templates?

This is a genuine structural difference. Deviniti's Data Center edition uses a single dedicated project as a template repository (a 'monorepo' model) — all templates live in one place. Its Cloud edition allows any project to act as a template repository ('multirepo'). STM does not use a separate repository-project concept; templates are scoped per-project or globally within the app's own template management screen, independent of your issue-tracking project structure.

Is STM cheaper than Deviniti's Issue Templates for Jira?

Both apps are priced independently on the Atlassian Marketplace by Jira user-count tier, and both offer free trials. Always compare current Marketplace pricing tables directly — tier structures and any bundled-app discounts change over time.

STM Issue Templates vs Deviniti Issue Templates for Jira — Which Is Right for Your Team?

This comparison is for teams who need reusable Jira issue templates and are weighing STM Issue Templates against Deviniti’s Issue Templates for Jira — the incumbent in this category, and the app that currently ranks for “jira issue templates” on Google. Both apps solve the same core problem (create issues with pre-filled fields, sub-tasks, and linked issues from a reusable definition) but organize and trigger that work differently.

The 30-second answer

STM centers on three concepts — Templates, Executors, and Bulk operations — done deeply. Templates can cascade (epic → story → sub-task), Executors auto-fire templates on issue creation or transition, and JQL-driven bulk-create/bulk-update lets you apply a template across every issue matching a query. STM also has a dedicated Update Templates feature for modifying issues that already exist, not just creating new ones.

Deviniti’s Issue Templates for Jira builds templates that carry sub-tasks and linked issues, applied manually, via its Create Structure post-function on a workflow transition, or via its REST API. Its distinguishing structural choice is the template repository model: Data Center stores all templates in one dedicated project (monorepo); Cloud allows any project to become a template repository (multirepo).

If your priority is JQL-driven bulk operations and updating existing issues from a template, STM is built around exactly that. If your priority is transition-triggered sub-task creation with a repository-project model for organizing templates, Deviniti’s app is the established option — it’s been in the category longer and holds the top Marketplace position for the broad “jira issue templates” search term.

Side-by-side

Capability	STM Issue Templates	Deviniti Issue Templates for Jira
Pre-filled issue fields from a template	✓	✓
Sub-task templates	✓	✓ (copied by default; scope-controlled via Smart Defaults)
Linked-issue templates	✓	✓
Cascading templates (epic → story → sub-task)	✓	Similar scope options (parent + stories + sub-tasks), different terminology — confirm current depth against Deviniti’s docs
JQL bulk-create / bulk-update	✓ (built-in)	Achievable via REST API / automation; not documented as a one-click JQL action
Update Templates (modify existing issues)	✓	Not confirmed as a named feature in Deviniti’s public docs
Auto-fire on workflow transition	✓	✓ (Create Structure post-function)
Manual “apply template” action	✓	✓
REST API to apply a template	Not a headline feature	✓
Dedicated template-repository project model	✗ (project/global scope in-app)	✓ (DC: single monorepo project; Cloud: any project, multirepo)
Works without a scripting/admin queue	✓	✓
Jira Cloud edition	✓	✓
Jira Data Center edition	✓	✓

When STM is the right pick

You want JQL-driven bulk operations. Apply a template — or an Update Template — to every issue matching a JQL query, built in, no REST scripting required.
You need to update issues that already exist, not just create new ones from a template. STM’s Update Templates is built specifically for this.
You want cascading, multi-level templates (epic → story → sub-task) managed from one place without a separate repository-project to administer.
You’re already comparing based on real usage. STM customers run templates with a large number of issue definitions in production — see the full STM feature list.

When Deviniti’s Issue Templates is the right pick

You want transition-triggered structure creation. The Create Structure post-function fires sub-task/linked-issue creation directly from a workflow transition — a good fit if your process is already transition-heavy.
You want a dedicated template-repository project to organize templates as their own manageable body of content, separate from live issue data (Data Center’s monorepo model, or Cloud’s per-project multirepo model).
You need REST API-driven template application as part of a broader integration or automation pipeline outside Jira’s own UI.
You’re already invested in Deviniti’s other apps and want to consolidate vendor relationships.

Cost considerations

Both apps are priced on the Atlassian Marketplace, tiered by Jira user count, with free trials available. Current pricing is always best read from the live listings, not quoted here:

Migration considerations

If you’re moving from Deviniti’s Issue Templates to STM:

Sub-tasks and linked issues copied via Deviniti’s default-copy behavior map to STM’s own sub-task and linked-issue template scope — recreate the same issue structure inside an STM template.
A Create Structure post-function tied to a workflow transition maps to an STM Executor configured to auto-fire on that same transition.
If you were relying on Deviniti’s dedicated template-repository project to browse and manage templates as a body of content, note that STM manages templates from its own in-app screen rather than a separate Jira project — plan for that workflow change with template owners.

Plan a transition the same way you would for any templating migration: pick one template, recreate it in the other app, run both side-by-side briefly, then retire the original.

Get started

The fastest way to evaluate STM against your current Deviniti templates is to install the free trial on a non-production project and recreate one existing template — including its sub-tasks — end to end.

Start STM free trial ↗ STM overview →