> 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/create-based-triggering.md).

# Create-based Triggering

Automatically create tickets upon issue creation for viable scenarios.

Create-based triggering represents the most aggressive automation approach in Pharos ticketing, automatically generating bugtracker work items the moment new issues are created. While this immediacy makes it powerful for critical scenarios, it also requires careful implementation to avoid overwhelming development teams with false positives and transient problems.

## How Create-based Triggering Works

When Pharos detects a new error pattern and creates an issue record for it, create-based ticketing rules evaluate that issue immediately against their configured criteria. If the issue matches, a ticket appears in your development backlog within seconds—long before the issue has accumulated significant occurrence data or impact metrics.

This contrasts with update-based triggering, which waits for issues to evolve and cross thresholds before creating tickets. Create-based rules operate on first impression rather than established patterns, making them both faster to respond and riskier to deploy.

## Viable Scenarios for Immediate Ticketing

Create-based automation works well in specific circumstances where immediate action is non-negotiable and error patterns are well-understood.

### Production-Critical Functional Areas

Certain business processes carry such high stakes that any failure warrants immediate attention regardless of occurrence counts or impact metrics. Order processing, payment transactions, regulatory reporting, and customer-facing integrations often fall into this category.

For these functional areas, the cost of waiting to see if an error recurs is higher than the cost of occasionally investigating a transient failure. A single failed payment transaction might represent thousands of dollars in lost revenue and customer trust. Creating a ticket immediately ensures that even one-time failures get investigated.

### Well-Characterized Error Patterns

Organizations with mature error handling and robust fingerprinting can leverage create-based automation for specific error types they've learned to recognize as always significant. Perhaps certain exception types in particular Apex classes have proven to always indicate genuine defects. Or maybe errors from specific third-party integrations always require coordination with external teams regardless of frequency.

This requires confidence built from historical data and pattern recognition that comes from months of observation. It's not a day-one capability but rather something that emerges after your organization understands its error landscape deeply.

### Known-Critical Metadata Changes

Sometimes create-based rules key off environmental factors rather than just error characteristics. An issue appearing immediately after a major deployment to production might warrant instant ticketing even if the error pattern itself isn't inherently critical. The temporal correlation between deployment and error suggests a regression that needs rapid validation.

Similarly, errors in recently modified classes or flows might trigger create-based rules while errors in stable, long-unchanged components go through normal update-based evaluation. The change context elevates priority beyond what the error itself would suggest.

## Why Create-based Automation Can Be Problematic

The immediate nature of create-based ticketing creates several challenges that organizations must address deliberately.

### Transient Issue Risk

Many issues that Pharos detects occur only once or twice and never recur. These might be environmental glitches, one-time data problems, user errors, or race conditions that don't reproduce. If create-based rules lack sufficient filtering, these transient issues generate tickets that developers close as "cannot reproduce" or "not a bug."

This creates several negative downstream effects. Development teams lose trust in automated tickets and begin ignoring them. The ticketing backlog fills with noise that obscures genuine priorities. And the operations team spends time investigating and closing false positive tickets rather than addressing real problems.

### Fingerprinting Challenges

Pharos fingerprinting works extremely well for most errors, but occasionally new error patterns get fingerprinted too broadly or too narrowly in their first occurrence. As more occurrences accumulate, the fingerprint often stabilizes and sometimes even splits into more specific sub-patterns.

Create-based rules don't get the benefit of this stabilization. They act on the initial fingerprint, which might group unrelated errors together or separate related ones. By the time the fingerprint stabilizes, tickets have already been created based on incomplete information.

### Baseline Understanding Requirements

Effective create-based rules require deep understanding of your organization's baseline error profile. Without that baseline, criteria become guesswork. You might think order processing errors always warrant immediate tickets, but perhaps 80% of order processing errors are actually validation failures from user data entry issues that belong in training channels rather than development backlogs.

This baseline understanding typically requires months of observation through manual triage and update-based automation before create-based rules can be tuned effectively.

## Implementation Strategies

Organizations that successfully implement create-based triggering typically follow careful, phased approaches rather than deploying it broadly.

### Start Extremely Narrow

The first create-based rule should be exceptionally specific, targeting the single most critical scenario you can identify with absolute confidence. Perhaps it's errors in a specific Apex class that handles payment processing, or integration failures with a regulatory reporting system.

Make the criteria so narrow that you're confident every matching issue genuinely warrants immediate attention. It's better to miss some cases initially than to generate false positives that erode trust.

### Layer Multiple Criteria

Effective create-based rules often combine several criteria rather than keying off a single factor. A rule might require that the issue be in production AND have a specific functional area AND involve certain object types AND not be in a list of known acceptable error patterns.

This layering reduces false positive rates significantly. An error in order processing might not always warrant immediate tickets, but an error in order processing that involves the payment object in production and occurs in a specific integration class very likely does.

### Monitor and Tune Aggressively

Create-based rules require ongoing validation that update-based rules don't need as much. Track the action rate on tickets these rules create—what percentage result in actual code changes versus being closed without action? If more than 20% of create-based tickets close without code changes, the criteria likely need tightening.

Also monitor for duplicates or related issues that should have been grouped but weren't. If your create-based rule is generating multiple tickets for what's actually the same problem, fingerprinting improvements might be needed before the rule can be effective.

{% hint style="danger" %}
**The Spam Risk**

Organizations that implement create-based triggering too broadly or too early often experience "ticket fatigue" where development teams begin ignoring all Pharos-generated tickets because the signal-to-noise ratio is too low.

Recovering from ticket fatigue is significantly harder than preventing it. Developers who've learned to ignore automated tickets require months of consistent, high-quality ticket generation to rebuild trust.

If you're unsure whether to implement a create-based rule, wait. Update-based automation provides 90% of the benefits with far less risk.
{% endhint %}

## Example: Order Processing Automation

Consider an organization that's identified order processing as genuinely critical through months of manual triage. Every order processing error they've seen has warranted developer attention, and the business has made clear that order failures are unacceptable even at low occurrence rates.

Their create-based rule might look like this:

**Trigger:** Issue Created\
**Criteria:**

* Environment Type equals "Production"
* Functional Area equals "Order Processing"
* Category equals "Apex" OR "Flow"
* Type does not contain "Validation" (filters out user data entry problems)
* Error Message does not contain "Duplicate Order" (known handled scenario)

**Action:**

* Create Jira Ticket using "Critical Production Bug" action
* Priority: High
* Assignment: DevOps Team
* Labels: order-processing, production, auto-generated

This rule is highly specific to a known critical area, excludes patterns they've learned are acceptable, and routes tickets to a team that understands the urgency. It's the result of months of observation, not a day-one implementation.

## Relationship to Triage Process

Create-based automation essentially embeds triage decisions into rule criteria. The rule encodes the judgment that "issues matching these criteria are always actionable" without requiring human review for each case.

This works when that judgment is reliably correct. When it's not, you've automated the creation of low-value tickets. The manual triage phase and subsequent update-based automation provide the empirical data needed to make these embedded triage decisions confidently.

Even with create-based rules in place, maintaining a periodic triage review of automatically created tickets validates that the automation continues to make good decisions. Environments evolve, business priorities shift, and error patterns change. Rules that were once perfectly calibrated can drift out of alignment if not monitored.

## When to Consider Create-based Rules

Consider implementing create-based automation when:

* You have 3+ months of manual triage and update-based automation data showing consistent patterns
* A specific functional area or error type has proven to always warrant tickets across dozens of historical examples
* Business stakeholders have explicitly classified certain failure scenarios as requiring immediate escalation
* Your fingerprinting is stable and accurate for the target error patterns
* You have capacity to monitor the automation closely for the first month after implementation

Avoid create-based automation when:

* You're new to Pharos or still learning your error baseline
* You're unsure whether errors in a functional area consistently warrant tickets
* Fingerprinting is still stabilizing for the target patterns
* Your development backlog is already overwhelmed with work
* You can't commit to monitoring the automation's effectiveness closely

{% hint style="success" %}
**Success Metrics for Create-based Rules**

A well-tuned create-based rule should have:

* **90%+ action rate**: Nearly all tickets result in code changes or documented triage decisions
* **< 5% false positive rate**: Very few tickets get closed as "not a bug" or "cannot reproduce"
* **< 10% duplicate rate**: Rarely creates multiple tickets for the same underlying problem
* **Developer satisfaction**: Development team views these tickets as high-value interrupts, not noise

If your create-based rules don't meet these metrics within their first month, consider reverting to update-based triggering for those scenarios.
{% endhint %}

## Next Steps

* Review [**Update-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/update-based-triggering.md) as a lower-risk alternative that provides most automation benefits
* Understand [**Ticketing Actions**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/ticketing-actions.md) to configure how create-based rules structure tickets
* Learn about [**Order of Execution**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/order-of-execution.md) to understand how create-based rules interact with other ticketing automation
