Choosing Automation for Jira Cloud: Automation, ScriptRunner, or Forge for Definition‑of‑Done Enforcement

Decision & Constraints

You want to enforce a Definition of Done (DoD) checklist whenever an issue moves to Done in a Jira Cloud company‑managed project. The constraints are:

• No on‑premises or server access – only cloud‑native tools.
• Low operational overhead – minimal manual maintenance.
• Conditional logic – apply the check only when the custom field Release Type equals Major.
• Audit trail – every validation attempt must be logged for compliance.

Supported Options

Three approaches satisfy the constraints:

• Native Jira Automation (rule‑based UI).
• Marketplace ScriptRunner (Groovy scripts).
• Atlassian Forge (Node.js/TypeScript apps).

Feature Comparison

Feature	Jira Automation	ScriptRunner	Forge
Execution model	Rule UI / JSON actions	Serverless Groovy scripts	Node.js/TypeScript functions
Conditional logic	Smart values + branch rules	Full Groovy + Jira API	Full TypeScript + REST/GraphQL
External calls	Webhook (30 s timeout)	HTTP client (30 s)	Fetch API (25 s, 128 MB)
Deployment	Instant – per‑project or global	Marketplace install – per‑user license	Git‑based CLI – per‑site, free tier + usage
Cost	Included in Premium/Enterprise (limits apply)	Per‑user subscription (adds cost)	Free tier + usage‑based pricing
Audit trail	Built‑in Execution Log	ScriptRunner log + optional custom logs	Custom logging + Connect audit API
Version control & rollback	Export/Import JSON	Script files in UI or Git sync	Git‑native, forge deploy --version
Limits	1,000 rule executions/month (Free) – higher on paid	30 s timeout, memory limits	25 s timeout, 128 MB, 100 invocations/sec
Team‑managed projects support	Yes (rule can be applied)	No (validators only in company‑managed)	No (validators only in company‑managed)

Trade‑off Summary

1. Automation is the fastest to set up for simple checks. No code, UI‑driven, and audit logs are native. However, complex branching, nested conditions, or external API calls become hard to maintain. The 1,000‑execution/month limit on the free tier can be a bottleneck for high‑volume projects.
2. ScriptRunner gives full Groovy control and deep access to Jira’s internal APIs, making it ideal for intricate logic. The downside is the need for a paid license, Groovy expertise, and the risk of hitting the 30 s timeout on long scripts. Version control is possible but requires additional configuration.
3. Forge offers modern, isolated runtime with TypeScript, Git integration, and secrets storage. It is well‑suited for maintainable, testable code and can easily be rolled back via version tags. The stricter 25 s timeout and 100 invocations/sec limit can be restrictive for heavy workloads, and the learning curve is steeper than the UI‑based Automation.

Concrete Forge Implementation

Below is a minimal Forge workflow validator that blocks a transition to Done unless the DoD checklist is satisfied. The example focuses on the Release Type field and a checklist stored in an entity property.

1. Manifest (manifest.yml)

modules:
  jira:workflowValidator:
    - key: validate-dod
      name: Definition of Done Validator
      description: Prevents transition to Done if DoD is incomplete
      events:
        - transition
      transitions:
        - name: Done
      function: validateDod

functions:
  validateDod:
    runtime: nodejs16.x
    handler: index.handler

2. Function (index.ts)

import { handler, context, runtime } from '@forge/api';

export const handler = async (event: any) => {
  const issueKey = event.issue?.key;
  if (!issueKey) {
    return { valid: false, errorMessage: 'No issue key found' };
  }

  // Retrieve issue details
  const issue = await runtime.issue.get({ issueIdOrKey: issueKey });
  const releaseType = issue.fields['customfield_12345']; // placeholder field ID

  // Only enforce for Major releases
  if (releaseType !== 'Major') {
    return { valid: true };
  }

  // Fetch DoD checklist from entity property (example)
  const props = await runtime.entity.property.get({ entityType: 'issue', entityId: issueKey, propertyKey: 'dodChecklist' });
  const checklist = JSON.parse(props?.value ?? '[]');

  const incomplete = checklist.filter((item: any) => !item.completed);
  if (incomplete.length > 0) {
    return {
      valid: false,
      errorMessage: `DoD incomplete: ${incomplete.map((i: any) => i.title).join(', ')}`
    };
  }

  return { valid: true };
};

3. Deployment

1. forge login – authenticate to your Atlassian account.
2. forge install --addon-key your-addon-key – install the app on the target site.
3. forge deploy – push the code. The CLI will output the deployment version.
4. In Jira, add the validator to the Done transition of your company‑managed workflow.

4. Validation Approach

• Unit test: Use vitest with mocks for @forge/api to verify the logic for different Release Type values and checklist states.
• Integration test: On a staging Jira Cloud site, create issues with Release Type = Major, populate the dodChecklist property, and attempt the transition. Assert that the transition is blocked when incomplete and allowed when complete.
• Load test: Run forge tunnel locally and use k6 to simulate 50 concurrent transition attempts. Verify that the 25 s timeout is not exceeded and that the 100 invocations/sec limit is respected.
• Monitoring: In the Forge console, enable metrics for the function. Cross‑check with Jira’s Automation execution log for any missing entries.

Practical Checklist Before Choosing

• Check current Automation limits: Administration > System > Automation.
• Review Forge pricing and limits in the Atlassian Developer Console.
• Confirm that the custom field ID (customfield_12345) matches your instance.
• Validate that the entity property key (dodChecklist) is correctly set up in the issue.
• Ensure that the target project is company‑managed; team‑managed projects only support Automation.

Conclusion

For most teams, Forge strikes the best balance: modern, version‑controlled code, built‑in secrets, and a clear audit trail. If you need zero code and are comfortable with the rule UI, Automation is a quick win. Choose ScriptRunner only when you require deep Groovy access or legacy API calls that are not exposed via REST.