> 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/manual-ticket-creation.md).

# Manual Ticket Creation

Use the create ticket button for selective actioning before moving to automation.

Manual ticket creation through the issue detail page represents the recommended starting point for organizations implementing Pharos ticketing integration. While it might seem counterintuitive to begin with a manual process when automation is available, this approach builds the foundation needed for successful long-term automation.

## The Create Ticket Button

The issue detail page includes a prominent create ticket button that generates a bugtracker work item with a single click. When invoked, this button triggers a configured ticketing action that packages the issue's context—including error messages, stack traces, impact metrics, occurrence patterns, and debugging links—into a properly formatted ticket in Jira or Azure DevOps.

This isn't a bare-bones ticket creation mechanism. The generated tickets contain rich context that developers need to begin investigation immediately. The issue fingerprint ensures that subsequent occurrences can be tracked back to the ticket, creating a persistent connection between detection and resolution.

## Why Start Manual

Starting with manual ticket creation serves multiple strategic purposes that pay dividends as your observability practice matures.

### Learning Your Baseline

Every Salesforce organization has a unique error profile shaped by its customization history, integration landscape, user base characteristics, and business processes. What constitutes a critical issue in one org might be routine noise in another. The first few weeks of manual triage and ticket creation reveal this profile empirically rather than through guesswork.

During this learning phase, you discover patterns about which errors actually impact operations, which resolve themselves, which indicate training issues versus code defects, and which functional areas generate the most significant problems. This knowledge becomes the criteria for automation rules later.

### Preventing Ticket Spam

Automated ticket creation without proper guardrails can overwhelm development backlogs with low-value work items. A production org might generate dozens of distinct issues weekly, but perhaps only 5-10 warrant immediate development attention. The remainder might be transient environmental problems, known issues with workarounds, or errors that need monitoring but not immediate action.

Manual creation provides a natural quality gate where human judgment filters out noise before it reaches the development team. This preserves the signal-to-noise ratio in your ticketing system and maintains developer trust in the automation.

### Building Triage Discipline

Manual ticket creation enforces engagement with the triage process. To create a ticket manually, someone must review the issue, assess its priority and impact, understand its technical context, and make a conscious decision that development action is warranted. This builds organizational muscle memory around what matters.

This discipline proves valuable even after automation is in place, because many issues will continue to require human judgment. Edge cases, business context that isn't captured in metadata, or situations where automation rules conflict with reality all benefit from the triage expertise developed during the manual phase.

## Where Manual Creation Remains Useful

Even after implementing automation rules, manual ticket creation retains permanent utility in several scenarios.

### Selective Actioning for Exceptions

Automation rules work well for common patterns but struggle with exceptions. An issue might not meet your automated thresholds numerically yet clearly indicates a serious problem based on business context. Perhaps it's affecting a VIP customer, or it's occurring in a functional area that's currently undergoing important business processes, or the error message suggests data corruption risk despite low occurrence counts.

Manual creation provides the escape valve for these judgment calls where human insight exceeds what automation can encode.

### Triage-First Workflows

Many organizations prefer a deliberate triage-then-action workflow where all issues are reviewed during scheduled triage sessions before any tickets are created. This approach works particularly well for teams that value tight control over their development backlog or operate in highly regulated environments where ticket creation itself has compliance implications.

In this model, manual creation isn't a fallback—it's the primary mechanism, with automation reserved only for truly exceptional cases like production-critical failures that demand instant escalation.

### Training and Validation

Manual creation serves as a validation mechanism for automation rules. When you implement a new automated ticketing rule, you might manually create tickets for several issues that match the rule criteria before enabling automation. This lets you verify that the rule produces the intended results without risking backlog spam if the criteria are misconfigured.

Similarly, manual creation provides hands-on training for new team members learning the triage process. They can review issues, make ticketing decisions, and see the results without the pressure of automation making decisions on their behalf.

## The Manual-to-Automated Transition

The transition from manual to automated ticket creation should be gradual and data-driven. After several weeks of manual triage, patterns emerge in your decision-making that can be encoded into automation rules.

You might notice that every issue in production with "Highest" priority and "Order Processing" functional area gets a ticket manually. That's a clear candidate for update-based automation. Or perhaps issues that reach 50 occurrences within 48 hours consistently warrant tickets—another automation opportunity.

The key is letting the manual data guide automation rather than guessing at rules. Some organizations track their manual ticketing decisions in spreadsheets or custom fields to perform this analysis explicitly. Others rely on reviewing their ticket creation patterns after a month or two of manual operation.

{% hint style="success" %}
**The Manual Phase Timeline**

Most organizations benefit from 2-4 weeks of purely manual ticket creation before implementing any automation. Organizations with complex environments or diverse error profiles might extend this to 6-8 weeks.

The right timeline is "when patterns become clear" rather than a fixed duration. If you're still discovering surprising issues or questioning your ticketing decisions after two weeks, continue the manual phase longer.
{% endhint %}

## Configuration Considerations

Manual ticket creation relies on configured ticketing actions that define how tickets should be structured. These actions specify the bugtracker project, issue type, priority mapping, label conventions, and description templates.

During the manual phase, it's worth maintaining multiple ticketing actions for different scenarios. You might have separate actions for production versus sandbox issues, for different development teams, or for different severity levels. This flexibility lets you route tickets appropriately without requiring complex automation logic.

The investment in well-configured actions during the manual phase pays off during automation, because the same actions can be reused in automated rules. The ticket format, routing, and structure remain consistent regardless of whether a human or a rule triggered creation.

## Measuring Effectiveness

The manual ticketing phase provides an opportunity to establish baseline metrics that will guide automation later. Track how many issues you review versus how many receive tickets—this becomes your signal-to-noise ratio. Monitor how long tickets remain open and how often they result in actual code changes versus being closed as "not a bug" or "won't fix."

These metrics help calibrate automation thresholds. If you find that 80% of manually created tickets lead to code changes, that's excellent signal quality worth preserving in automation. If only 40% result in changes, your criteria might be too loose, or you might be creating tickets for training issues that belong in different channels.

## Practical Workflow Example

A typical manual ticketing workflow during the learning phase might look like this:

The operations team holds a weekly triage session where they review all new and recently updated issues from production. For each issue, they examine the error message, stack trace, occurrence pattern, and user impact metrics. They check whether it's a known issue, whether it's been discussed previously, and whether any workarounds exist.

For issues that warrant development action, they set the status to "Actioned," add triage notes explaining the business impact and urgency, and click the create ticket button using the appropriate ticketing action. The resulting ticket appears in the development backlog with full context, and the issue record in Pharos maintains a link to that ticket for tracking.

Issues that don't warrant immediate tickets are set to appropriate statuses for monitoring, documentation, or resolution tracking. The team documents why tickets weren't created, building a knowledge base of decision criteria.

After four weeks, the team reviews their ticketing patterns and identifies that all "High" priority production issues in three specific functional areas consistently received tickets. They implement update-based automation rules for those patterns while maintaining manual triage for everything else.

{% hint style="warning" %}
**Avoid These Common Pitfalls**

**Over-ticketing to "get everything tracked"**: Creating tickets for every issue defeats the purpose of triage and trains developers to ignore Pharos-generated tickets.

**Under-ticketing to "avoid bothering developers"**: Being too conservative means significant issues don't get attention, undermining confidence in the observability practice.

**Inconsistent criteria**: Different team members applying different standards creates confusion and unreliable automation data later.

Establish and document clear ticketing criteria early, even if those criteria evolve with experience.
{% endhint %}

## Next Steps

Once you've established reliable manual ticketing patterns, explore automation approaches:

* [**Update-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/update-based-triggering.md) - Automate ticket creation for issues matching proven patterns
* [**Ticketing Actions**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/ticketing-actions.md) - Configure reusable actions for consistent ticket formatting
* [**Create-based Triggering**](https://docs.pharos.ai/platform-overview/pharos-platform-architecture/ticketing-and-bugtracking/issue-level-ticketing/create-based-triggering.md) - Immediate automation for critical scenarios (advanced)
