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

# Update-based Triggering

Automatically create tickets on issue updates with fine-tuned criteria to avoid backlog noise.

Update-based triggering represents the most common and successful automation strategy in production Pharos deployments. Rather than creating tickets immediately when issues appear, these rules monitor issue evolution and generate tickets when problems demonstrate sustained significance through occurrence counts, user impact, or frequency patterns. This approach naturally filters transient problems while ensuring persistent issues receive development attention.

## The Update-Based Philosophy

The fundamental insight behind update-based triggering is that issue significance reveals itself over time. A single error occurrence might be a cosmic ray bit flip, environmental glitch, or user mistake. But an error that occurs 50 times across 10 users over two days has demonstrated that it's a genuine problem worth investigating.

Update-based rules let the data prove the issue's importance before consuming development resources. This dramatically improves the signal-to-noise ratio of automated tickets compared to create-based approaches, making update-based triggering the recommended automation starting point for most organizations.

## How Update-based Rules Work

When an issue receives a new log occurrence, Pharos recalculates its aggregate metrics—total occurrences, unique users impacted, occurrence frequency, and time-based patterns. Update-based ticketing rules then evaluate the issue against their configured thresholds and criteria.

If an issue that didn't previously match a rule's criteria now does because it crossed a threshold, the rule triggers and creates a ticket. This might happen after the 25th occurrence, or when the 5th unique user is impacted, or when the issue reaches 10 occurrences in a single day.

The key distinction from create-based rules is that update-based evaluation happens after the issue has accumulated evidence of significance. The first occurrence alone doesn't trigger anything—the pattern of subsequent occurrences determines whether a ticket gets created.

## Common Threshold Strategies

Organizations typically employ several types of thresholds in their update-based rules, often combining multiple threshold types in a single rule for more precise targeting.

### Absolute Occurrence Counts

The simplest threshold strategy counts total occurrences across the issue's lifetime. A rule might create tickets for any issue reaching 50 total occurrences, or 100 occurrences for lower-priority categories.

This approach works well for errors that should never be extremely common. If something is happening 50+ times, it's worth investigation even if the occurrences are spread across weeks. Absolute counts provide a backstop that ensures nothing grows indefinitely without attention.

### Time-Windowed Occurrence Rates

More sophisticated rules evaluate occurrence density within time windows. An issue might need 25 occurrences within 24 hours to trigger, or 10 occurrences within one hour. This distinguishes between errors that happen occasionally over weeks (potentially acceptable) versus errors that spike rapidly (definitely concerning).

Time-windowed thresholds are particularly valuable for catching regressions. An issue that suddenly accelerates from one occurrence per day to 10 per hour indicates something changed—perhaps a deployment introduced a bug, or a data issue emerged, or user behavior shifted. The velocity of occurrence matters as much as the absolute count.

### User Impact Thresholds

Some rules key off unique user counts rather than occurrence counts. An issue might need to impact 10 different users before warranting a ticket, regardless of whether that's 15 occurrences or 200.

This strategy recognizes that errors affecting many users indicate systemic problems rather than edge cases. A single user hitting an error 100 times might reflect unusual usage patterns, but 10 different users each hitting it once suggests a common scenario that needs fixing.

### Priority-Based Combinations

Many effective update-based rules combine priority levels with occurrence thresholds. High-priority issues might warrant tickets after just 10 occurrences, while low-priority issues might need 100. This allows the automation to respond to issue severity while still filtering transient problems.

The priority dimension often comes from triage processes where human judgment classified issues, or from metadata like functional area where certain business processes are deemed more critical than others.

## Why Update-based Automation Succeeds

Update-based triggering succeeds where create-based approaches struggle because it solves several key problems inherent in automated ticket creation.

### Natural Transient Filtering

The majority of issues that appear in Pharos occur only once or twice and never recur. These might be environmental anomalies, one-time data problems, or race conditions that don't reproduce. Update-based rules automatically filter these out by requiring sustained occurrence patterns before triggering.

This filtering happens without any explicit "ignore transient issues" logic. The rules simply demand evidence of significance, and transient issues never accumulate that evidence. The result is dramatically better signal-to-noise ratios in your ticketing backlog.

### Fingerprint Stabilization

Issue fingerprints sometimes evolve in the first few occurrences as Pharos learns the error pattern more precisely. An issue that initially groups several loosely related errors might split into more specific sub-issues after 10-15 occurrences provide better pattern data.

Update-based rules benefit from this stabilization because they don't trigger until after the fingerprint has settled. The ticket that eventually gets created reflects the mature, accurate fingerprint rather than the initial approximation.

### Data-Driven Threshold Calibration

Unlike create-based rules that must anticipate which new issues warrant tickets, update-based rules can be calibrated against historical data. After several weeks of manual triage, you can analyze which issues received tickets and what their occurrence counts, user impacts, and other metrics were at the time of ticketing.

This empirical analysis reveals the actual thresholds your organization uses for ticketing decisions. Perhaps you discover that you never create tickets for issues under 15 occurrences, or that issues above 40 occurrences always get tickets. These observations become the thresholds in your update-based rules.

## Baseline Understanding Requirements

Update-based automation requires understanding your organization's baseline error profile, but this requirement is far less stringent than for create-based rules. You don't need to predict which new error patterns will be significant—you just need to know what occurrence counts and impact levels have historically indicated significance.

This baseline can be established relatively quickly through manual triage. Even 2-4 weeks of consistent triage provides enough data to set initial thresholds for update-based rules. These thresholds can then be refined as you observe the automation's effectiveness over subsequent weeks.

The baseline also helps you understand how noisy your environment is. An organization that generates 50 new issues weekly but only tickets 5 of them has a very different profile than one that generates 10 new issues weekly and tickets 8 of them. Update-based thresholds should reflect these environmental differences.

{% hint style="success" %}
**The Sweet Spot for Update-based Rules**

Update-based automation provides about 90% of the benefits of full automation with perhaps 20% of the risk. Issues that matter most—those with sustained occurrence patterns—get automatic tickets. Edge cases and transient problems get filtered naturally. And you can calibrate thresholds against real data rather than guessing.

This is why update-based triggering is the recommended automation approach for most organizations, especially those implementing ticketing automation for the first time.
{% endhint %}

## Fine-Tuning to Avoid Noise

Even update-based rules can generate noise if thresholds are set too low or criteria are too broad. Fine-tuning becomes an ongoing practice rather than a one-time configuration task.

### Monitoring Action Rates

The key metric for update-based rule effectiveness is the action rate—what percentage of automatically created tickets result in code changes or other genuine resolutions versus being closed as duplicates, not-a-bug, or won't-fix outcomes.

A well-tuned update-based rule should have an action rate above 70%. If you're seeing 50% or below, the rule is generating too much noise and needs tightening. Perhaps the occurrence threshold is too low, or the rule is including error categories that don't actually warrant tickets at those volumes.

### Excluding Known Acceptable Patterns

As your observability practice matures, you'll identify certain error patterns that occur regularly but don't require tickets. Perhaps they're known limitations that have been documented, or validation errors from expected user behavior, or integrations errors during scheduled maintenance windows.

Update-based rules should explicitly exclude these patterns even if they cross occurrence thresholds. This prevents the automation from re-creating tickets for problems you've already evaluated and determined don't warrant action.

### Adjusting for Environmental Noise

Different environments have different baseline noise levels. Your production environment might be relatively clean with most errors being genuinely significant, while sandbox environments might have higher noise from experimental work and testing activities.

Update-based rules should account for these environmental differences, perhaps using higher thresholds in sandbox environments or excluding certain error categories entirely from sandbox automation. The same occurrence count means different things in different contexts.

### Seasonal and Cyclic Adjustments

Some organizations experience seasonal patterns in their error profiles. Perhaps certain errors spike during specific business cycles, or user volumes change dramatically at month-end or year-end. Update-based thresholds might need adjustment to account for these patterns.

This doesn't necessarily mean changing the rules seasonally. Instead, it might mean using rate-based thresholds that adapt to overall volume rather than absolute count thresholds. An issue occurring 50 times might be concerning during a slow period but completely normal during peak season.

## Implementation Example

Consider an organization that has completed four weeks of manual triage and analyzed their ticketing patterns. They discovered that they consistently create tickets for production issues that meet any of these patterns:

* High priority issues reaching 25 occurrences
* Medium priority issues reaching 50 occurrences or impacting 10+ users
* Any priority issues in "Order Processing" functional area reaching 15 occurrences

They translate this into three update-based rules:

**Rule 1: High Priority Production Issues**

* Trigger: Issue Updated
* Criteria: Environment = Production, Priority = High, Total Occurrences >= 25
* Action: Create Jira ticket using "Production Bug" template

**Rule 2: Medium Priority Production Issues**

* Trigger: Issue Updated
* Criteria: Environment = Production, Priority = Medium, (Total Occurrences >= 50 OR Unique Users >= 10)
* Action: Create Jira ticket using "Production Bug" template

**Rule 3: Order Processing Critical Path**

* Trigger: Issue Updated
* Criteria: Environment = Production, Functional Area = "Order Processing", Total Occurrences >= 15
* Action: Create Jira ticket using "Critical Production Bug" template, assign to DevOps team

These rules reflect their actual decision-making patterns from manual triage, giving confidence that the automation will make similar quality decisions.

## Commenting on Existing Tickets

Update-based automation doesn't have to be limited to ticket creation. Rules can also add comments to existing tickets when issues evolve significantly. This keeps development teams informed about issue progression without creating duplicate tickets.

For example, a rule might add a comment to an issue's ticket when:

* Occurrences double since the ticket was created
* User impact spikes suddenly (perhaps from 5 users to 20)
* The issue that was thought resolved starts recurring again
* Error patterns shift to indicate the problem is evolving

These comment-based updates provide continuous feedback about issue severity without the noise of creating new tickets for each development.

## Relationship to Manual Triage

Update-based automation doesn't eliminate the need for manual triage—it changes its role. Rather than manually creating every ticket, triage becomes focused on exceptions, edge cases, and issues that fall outside automated patterns.

Many organizations maintain a weekly triage cadence even after implementing comprehensive update-based automation. This triage reviews issues that haven't triggered automation rules to verify that nothing important is being missed, reviews automatically created tickets to validate the automation is working well, and identifies new patterns that might warrant additional automation rules.

This human-in-the-loop oversight ensures the automation continues to serve its purpose and doesn't drift into generating noise as the environment evolves.

{% hint style="warning" %}
**Start Conservative, Loosen Gradually**

When first implementing update-based automation, err on the side of higher thresholds rather than lower. It's much easier to lower thresholds after observing that significant issues are being missed than to raise thresholds after flooding the development backlog with noise.

A conservative starting point might be 50 occurrences for general issues, 25 for high-priority issues in critical functional areas. After a month of observation, you can adjust based on what you learn about tickets being created too late versus automation working well.
{% endhint %}

## Success Metrics

Track these metrics to validate your update-based automation is working effectively:

**Action Rate:** Percentage of automatically created tickets that result in code changes. Target: 70%+

**Time to Ticket:** How long after first occurrence does the ticket get created? This should align with when issues demonstrate sustained patterns (typically 1-5 days for most rules).

**Coverage Rate:** What percentage of manually created tickets could have been created automatically based on the same criteria? High coverage suggests your rules reflect your actual decision-making well.

**False Negative Rate:** How often does manual triage create tickets for issues that didn't trigger automation? Low rates indicate good rule coverage.

**Developer Satisfaction:** Do developers view automated tickets as high-value work items? Regular feedback from development teams validates automation quality better than any metric.

## Next Steps

* Explore [**Ticketing Actions**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/ticketing-actions.md) to configure how update-based rules structure their tickets
* Review [**Order of Execution**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/order-of-execution.md) to understand how rules prevent duplicate ticket creation
* Consider [**Create-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/create-based-triggering.md) only after update-based automation is working well
