> For the complete documentation index, see [llms.txt](https://docs.pharos.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/ticketing-actions.md).

# Ticketing Actions

Learn about reusable ticketing actions for creation and comments across manual and automated workflows.

Ticketing actions provide the reusable building blocks that both manual and automated workflows use to create and update bugtracker tickets. Rather than configuring ticket formatting and routing separately for each button click or automation rule, you define actions once and invoke them across multiple contexts. This ensures consistency, simplifies configuration, and makes it easy to maintain standards as your ticketing integration evolves.

## The Action Model

A ticketing action encapsulates everything needed to create or update a ticket in Jira or Azure DevOps. This includes which bugtracker project to use, what issue type to create, how to map priorities between Pharos and the bugtracker, what description template to apply, which labels or components to assign, and what assignment rules to follow.

When someone clicks the create ticket button on an issue or an automation rule triggers, they invoke a specific ticketing action by name. That action handles all the details of structuring the ticket appropriately for its context, freeing the person or rule from needing to specify those details every time.

This separation between "when to ticket" and "how to ticket" proves valuable as complexity grows. You might have a dozen different ticketing rules for various scenarios, but they all invoke three or four carefully configured actions. When you need to change ticket formatting or routing, you update the actions rather than modifying every rule individually.

## Types of Ticketing Actions

Pharos supports two fundamental types of ticketing actions, each serving distinct purposes in the ticket lifecycle.

### Creation Actions

Creation actions generate new tickets in your bugtracker. These are the actions invoked by the create ticket button on issue details or by automated ticketing rules that create tickets based on issue patterns.

A creation action defines the complete structure of tickets it creates. This includes the summary format that will appear as the ticket title, the description template that structures the ticket body, the default priority and severity mappings, the project and issue type to use, and any standard labels, components, or custom field values that should be applied.

Creation actions can also specify assignment logic. Perhaps tickets should always go to a specific team, or maybe assignment should be based on functional area metadata from the issue. The action configuration handles these routing decisions so that tickets arrive in the right queues without manual intervention.

### Comment Actions

Comment actions add notes to existing tickets rather than creating new ones. These are particularly valuable for update-based automation that wants to inform development teams about issue evolution without generating duplicate tickets.

A comment action defines what triggers a comment, what template to use for comment text, and what information to include. Perhaps a comment action fires when an issue's occurrence count doubles, adding a note to the ticket like "Occurrence volume has spiked from 50 to 100 in the past 24 hours. User impact now 15 unique users."

Comment actions respect the ticket lifecycle—they only add comments to tickets that are still open or in specific states you configure. There's no value in adding comments to closed tickets, so actions can be configured to skip commenting when issues have been marked resolved in both systems.

## Why Actions Are Reusable

The reusability of ticketing actions emerges from recognizing that ticket structure depends more on ticket purpose than on what triggered creation. Whether a high-priority production bug ticket gets created manually via button click or automatically via an update-based rule doesn't change how that ticket should be structured—it should use the same template, routing, and format either way.

This allows you to define relatively few actions that serve many triggering contexts. A typical organization might maintain:

* A "Production Bug" action for general production issues
* A "Critical Production Bug" action for high-severity production issues
* A "Sandbox Issue" action for lower environments
* A "Tech Debt" action for known issues being tracked for future cleanup
* A "Regression" action for issues that recur after being marked resolved

Each of these actions gets invoked from multiple places—manual buttons, create-based rules, update-based rules—but always produces consistent, appropriately structured tickets.

## Configuration Dimensions

Ticketing actions encapsulate numerous configuration dimensions that would be tedious to specify repeatedly if not centralized.

### Project and Issue Type Selection

The most fundamental action configuration is which bugtracker project to target and what issue type to create. Your organization might have separate projects for different teams, products, or priorities. The action defines this routing so that tickets automatically land in the appropriate backlog.

Issue type selection determines how the ticket appears in your bugtracker. Jira offers bug, story, task, epic, and custom types. Azure DevOps has bug, user story, feature, and epic. The action maps Pharos issues to the appropriate bugtracker type based on your workflow conventions.

### Priority and Severity Mapping

Pharos priority levels (Lowest, Low, Medium, High, Highest) may not map directly to your bugtracker's priority or severity schemes. The action defines this mapping explicitly, ensuring that a High priority Pharos issue becomes a P1 Jira bug or High severity Azure DevOps item according to your conventions.

These mappings can be sophisticated. Perhaps Critical Pharos issues always map to P0, but High Pharos issues map to either P1 or P2 depending on what functional area they belong to. The action can encode these contextual priority decisions.

### Description Templates

The ticket description that appears in your bugtracker comes from a template defined in the action. This template uses merge fields to pull data from the issue—error messages, stack traces, occurrence counts, user impact, recent changes from audit trail, and debugging links back to Pharos.

Well-crafted description templates provide developers with everything they need to begin investigation immediately. They present information in a structured, scannable format rather than a wall of text. And they include direct links back to Pharos where developers can explore logs, related issues, and detailed context.

Templates can vary significantly between actions. A critical production bug template might emphasize impact metrics and urgency, while a tech debt template might focus on code quality concerns and architectural context.

### Labels, Components, and Custom Fields

Actions can automatically apply bugtracker metadata that helps with filtering, routing, and reporting. Perhaps all Pharos-generated tickets get a `pharos-auto` label to distinguish them from manually created ones. Or maybe tickets get labeled with their functional area like `order-processing` or `integration`.

Component assignment works similarly, automatically categorizing tickets in Jira's component system based on issue metadata. Custom fields can be populated from issue data—perhaps a custom "Error Category" field gets set to the Pharos category value, or a "User Impact" field gets set to the unique user count.

This automatic metadata application ensures consistency and supports downstream reporting and filtering without requiring manual effort on every ticket.

### Assignment Rules

Some actions include assignment logic that routes tickets to specific teams or individuals. This might be static—all critical production bugs go to the DevOps team—or dynamic based on functional area, with order processing issues going to one team and integration issues to another.

Assignment rules can also be left undefined, allowing normal bugtracker project workflows to handle assignment through their existing triage processes. Not all organizations want automated assignment, and actions accommodate both preferences.

## Using Actions in Manual Workflows

When someone clicks the create ticket button on an issue detail page, they select which action to use from a configured list of available actions. This gives human operators flexibility to route tickets appropriately based on context that automation might not capture.

Perhaps most issues in a functional area warrant tickets using the standard "Production Bug" action, but one particular issue has business context that makes it more urgent, so the operator chooses "Critical Production Bug" instead. Or maybe an issue clearly represents technical debt rather than a bug, so the operator selects the "Tech Debt" action that routes to a different backlog.

This action selection capability ensures that manual ticketing retains full flexibility even though the actions themselves standardize ticket structure. You get consistency where it matters—ticket format, required information, metadata—while preserving discretion where it matters—routing, priority, and classification.

## Using Actions in Automated Rules

Ticketing rules specify which action to invoke when their criteria are met. An update-based rule targeting high-priority production issues might invoke the "Critical Production Bug" action, while a create-based rule for regression detection might invoke a "Regression" action that uses different templates and routing.

The action handles all structural concerns, leaving the rule to focus solely on when to trigger. This separation of concerns makes rules much simpler to configure and maintain. The rule defines the pattern that warrants a ticket; the action defines what that ticket looks like.

This also means you can have multiple rules invoking the same action. Perhaps you have both create-based and update-based rules for order processing issues, and both invoke the "Order Processing Critical" action. The tickets they create will be identically structured even though one triggers immediately and the other waits for occurrence thresholds.

## Multiple Actions for Different Contexts

Most organizations benefit from maintaining several distinct actions that serve different ticketing scenarios. The right number varies, but typically ranges from three to ten actions covering the span of use cases.

Too few actions and you lose the ability to route or format tickets appropriately for their context. Too many actions and configuration becomes burdensome, with excessive options that confuse operators and make maintenance difficult.

A good starting set might include:

**Production Bug Action**: General-purpose action for production issues with standard priority and routing.

**Critical Production Action**: Higher-urgency template and routing for business-critical production issues.

**Sandbox Issue Action**: Lower-priority formatting for issues from non-production environments.

**Regression Action**: Special template for issues that recur after being marked resolved, flagging them as potential regression issues.

**Comment Update Action**: Not a creation action, but a comment action that adds notes to existing tickets when issues evolve.

From this foundation, organizations often add actions for specific functional areas that need special routing or template emphasis. An "Integration Failure" action might route to the integrations team and emphasize API details in its template. An "Order Processing" action might alert business stakeholders in addition to creating development tickets.

{% hint style="success" %}
**Action Design Best Practice**

Design actions around ticket purpose and audience rather than around triggering mechanisms. Ask "what does a developer need to see in this ticket?" and "where should this ticket be routed?" rather than "what rule will create this ticket?"

This purpose-driven design naturally leads to reusable actions that serve multiple triggering contexts while ensuring tickets are consistently well-structured for their intended audience.
{% endhint %}

## Template Customization Strategies

The description template in ticketing actions deserves particular attention because it defines what context reaches your development team. Templates should be information-dense without being overwhelming, structured for quick scanning, and rich with actionable links.

Effective templates typically include these sections:

**Error Summary**: The core error message and exception type in prominent, easy-to-find formatting.

**Impact Metrics**: How many times has this occurred? How many users affected? What's the trend? This helps developers prioritize.

**Technical Context**: Category, type, functional area, involved metadata. Where in the codebase or configuration does this live?

**Stack Trace**: For Apex errors, the enriched stack trace with code context. For flows, the visual flow path showing where failure occurred.

**Debugging Resources**: Direct links to the issue in Pharos, related logs, audit trail snapshots, and any other context that aids investigation.

**Recent Changes**: Relevant audit trail entries showing recent metadata changes that might explain the error's appearance.

Templates can be formatted with markdown, HTML, or wiki markup depending on your bugtracker. Use this formatting to create scannable hierarchy—headers, bold key information, code blocks for stack traces, and clear visual separation between sections.

## Maintaining Actions Over Time

Ticketing actions require periodic review and refinement as your workflows evolve. Perhaps you discover that developers consistently ask for information that's not in the template, suggesting the template should be enhanced. Or maybe certain actions create tickets that rarely get worked, suggesting routing or priority mapping needs adjustment.

Schedule quarterly reviews of your ticketing actions to validate they still serve their purposes effectively. Examine the action rate on tickets created by each action—do they lead to code changes or get closed without action? Review developer feedback about ticket quality. Analyze whether actions are routing tickets appropriately based on how long tickets sit before being picked up.

These reviews often reveal opportunities to split or merge actions. Perhaps an action that initially served one purpose has evolved to serve two distinct scenarios that would benefit from separate templates. Or maybe two actions that seemed different initially are actually creating nearly identical tickets and could be merged.

## Example: Progressive Action Refinement

Consider an organization that starts with a single "Production Bug" action. This action uses a general template and routes to a shared development backlog with Medium priority.

After two months, they notice that order processing issues created with this action consistently get escalated to High priority manually after creation. They create a new "Order Processing Critical" action with a specialized template that emphasizes business impact and routes directly to the order processing team with High priority.

A month later, they observe that some production bugs are actually validation errors from user data entry issues, not code defects. These tickets get closed as "not a bug" frequently. They refine their automation rules to exclude validation errors from automated ticketing, but maintain the ability to manually create tickets for validation issues using a new "Training Issue" action that routes to the support team rather than development.

This progressive refinement reflects growing sophistication in their ticketing integration without requiring wholesale replacement of their configuration. Each new action serves a newly understood distinct purpose while existing actions continue working well for their intended scenarios.

{% hint style="info" %}
**Action Naming Conventions**

Use clear, descriptive names for actions that communicate their purpose and routing. "Production Bug" and "Critical Production Bug" immediately convey severity differences. "Order Processing Critical" indicates both functional area and urgency.

Avoid generic names like "Action 1" or overly technical names like "Jira PROJ-SFORCE-BUG Template 3" that don't communicate purpose at a glance.
{% endhint %}

## Integration with Triage Workflow

Ticketing actions align naturally with triage workflow stages. During triage, operators assess issues and assign priorities, functional areas, and status values. These triage decisions directly inform which action should be used if ticketing is warranted.

A high-priority production issue in order processing that's being set to "Actioned" status might warrant the "Order Processing Critical" action. A medium-priority issue in a non-critical area might use the general "Production Bug" action. A low-priority issue might not get ticketed at all, or might use a "Tech Debt" action that routes to a long-term improvement backlog.

The action selection becomes an extension of triage judgment rather than a separate decision. This integration ensures that the care taken during triage translates directly into appropriate ticket routing and formatting.

## Next Steps

With a solid understanding of ticketing actions, explore how they're invoked:

* [**Manual Ticket Creation**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/manual-ticket-creation.md) - Using actions through the create ticket button
* [**Update-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/update-based-triggering.md) - Invoking actions automatically based on issue patterns
* [**Create-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/create-based-triggering.md) - Immediate action invocation for critical scenarios

Or understand execution safeguards:

* [**Order of Execution**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/order-of-execution.md) - How Pharos prevents duplicate tickets when multiple rules might apply
