Tickets Overview

Tickets System

The Pulse ticketing system provides enterprise-grade support ticket management with automation, SLA tracking, escalation rules, and integrations. This comprehensive system helps organizations deliver exceptional customer support efficiently.

Core Features

🎫 Ticket Management

Create, read, update, and delete tickets
Rich ticket metadata (status, priority, assignment, tags, custom fields)
Full-text search across subjects, descriptions, and comments
Filtering and sorting by any field
Bulk operations for efficiency
Ticket merging for duplicates

⚡ Automation Rules

Automatically perform actions based on ticket events and conditions:

Trigger on ticket creation, updates, status changes, assignments
Evaluate conditions with flexible operators
Execute actions like status changes, assignments, priority updates
Sequential rule execution with configurable order
Dry-run testing before enabling rules
Complete audit trail of all executions

Learn more about Automation Rules →

📊 SLA Tracking

Monitor and enforce Service Level Agreements:

Configurable SLA thresholds per priority level
Track first response time and resolution time
Real-time SLA status (on_time, at_risk, breached, paused)
Business hours support
Automatic pause when waiting on customer
Comprehensive compliance reporting

Learn more about SLA Tracking →

🚨 Escalation Rules

Ensure tickets receive timely attention:

Time-based automatic escalation
Priority-specific escalation paths
Multi-level escalation support
Flexible escalation targets (manager, team, user, rotation)
Multi-channel notifications (email, SMS, Slack, in-app)
Condition-based escalation logic

Learn more about Escalation Rules →

🔗 Maverick Integration

Bi-directional synchronization with Maverick merchant services platform:

Pull tickets from Maverick to Pulse
Push status changes and comments back to Maverick
Automatic category and status mapping
Intelligent conflict prevention
Document synchronization
Webhook support for real-time updates

Learn more about Maverick Integration →

Quick Start

Creating Your First Ticket

const response = await fetch("/api/tickets", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${token}`,
  },
  body: JSON.stringify({
    subject: "Unable to log in",
    description: "User cannot log in to their account after password reset",
    priority: "high",
    typeId: 3,
    assignedToTeamId: 5,
  }),
});

const ticket = await response.json();
console.log(`Ticket created: ${ticket.ticketNumber}`);

Listing Open Tickets

const response = await fetch("/api/tickets?status=open&sortBy=priority", {
  headers: {
    Authorization: `Bearer ${token}`,
  },
});

const { tickets, pagination } = await response.json();
tickets.forEach((ticket) => {
  console.log(`${ticket.ticketNumber}: ${ticket.subject} [${ticket.priority}]`);
});

Adding a Comment

const response = await fetch("/api/tickets/1234/comments", {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Bearer ${token}`,
  },
  body: JSON.stringify({
    body: "We have identified the issue and are working on a resolution.",
    isInternal: false,
    notifyCustomer: true,
  }),
});

Ticket Lifecycle

Understanding the ticket lifecycle is key to effective support management:

┌──────────┐
│   open   │ ← New ticket created
└────┬─────┘
     │
     ▼
┌──────────────┐
│ in_progress  │ ← Agent actively working
└──────┬───────┘
       │
       ├──────────────────────────┐
       │                          │
       ▼                          ▼
┌──────────────────┐    ┌──────────────────┐
│ waiting_customer │    │    resolved      │
│  (SLA paused)    │    │ (Awaiting verify)│
└──────┬───────────┘    └────────┬─────────┘
       │                         │
       │                         ▼
       │                 ┌──────────┐
       └────────────────>│  closed  │ ← Ticket archived
                         └──────────┘

Status Definitions

open - Newly created, awaiting assignment or first response
in_progress - Agent actively working on the ticket
waiting_customer - Awaiting customer response (SLA timer paused)
resolved - Issue resolved, awaiting customer confirmation
closed - Ticket completed and archived

Priority Levels

Priority determines SLA thresholds and escalation timing:

Priority	Use Case	Default First Response	Default Resolution
Urgent	System down, critical business impact	15 minutes	4 hours
High	Major feature not working, significant impact	1 hour	8 hours
Medium	Minor issue, moderate impact	4 hours	24 hours
Low	Question, low impact	8 hours	48 hours

Ticket Properties

Core Fields

id - Unique numeric identifier
ticketNumber - Human-readable ID (e.g., PULSE-1234)
subject - Brief title/summary
description - Detailed description of the issue
status - Current status (open, in_progress, etc.)
priority - Priority level (urgent, high, medium, low)

Assignment

assignedToUserId - Assigned user ID
assignedToTeamId - Assigned team ID
Can be assigned to both user and team simultaneously

Categorization

typeId - Ticket type (e.g., Bug, Feature Request, Question)
categoryId - Category (e.g., Billing, Technical, Account)
tags - Array of string tags for flexible categorization

SLA Tracking

slaStatus - Current SLA status (on_time, at_risk, breached, paused)
slaFirstResponseDue - When first response is due
slaFirstResponseMet - Whether first response SLA was met
slaResolutionDue - When resolution is due
slaResolutionMet - Whether resolution SLA was met
firstResponseTime - Actual first response time (minutes)
resolutionTime - Actual resolution time (minutes)

Timestamps

createdAt - When ticket was created
updatedAt - Last modification time
resolvedAt - When ticket was resolved
closedAt - When ticket was closed

Metadata

createdBy - User who created the ticket
customFields - JSON object for custom data
externalSource - Source system (e.g., ‘maverick’)
externalTicketId - ID in external system

Common Workflows

Workflow 1: New Ticket with Auto-Assignment

// 1. Create ticket
const ticket = await createTicket({
  subject: "Payment processing error",
  priority: "urgent",
});

// 2. Automation rule triggers (auto-assign urgent tickets)
// Ticket automatically assigned to team

// 3. Escalation rule monitors ticket age
// Escalates if not resolved within SLA

Workflow 2: Customer Support Interaction

// 1. Customer creates ticket (via web form, email, API)
const ticket = await createTicket({
  subject: "How do I reset my password?",
  priority: "low",
});

// 2. Agent responds
await addComment(ticket.id, {
  body: "You can reset your password by clicking...",
  isInternal: false,
});

// 3. Waiting for customer
await updateTicketStatus(ticket.id, "waiting_customer");
// SLA automatically pauses

// 4. Customer responds (triggers status change)
await updateTicketStatus(ticket.id, "in_progress");

// 5. Agent resolves
await updateTicketStatus(ticket.id, "resolved");

// 6. Auto-close after 7 days (automation rule)

Workflow 3: Escalation Path

// 1. High priority ticket created
const ticket = await createTicket({
  subject: "Critical security vulnerability",
  priority: "urgent",
});

// 2. No response within 15 minutes
// Escalation rule: Level 1 - Escalate to security team

// 3. No resolution within 2 hours
// Escalation rule: Level 2 - Escalate to manager

// 4. Approaching SLA breach (at 80%)
// Notification sent to director

// 5. SLA breached
// Automation rule: Increase priority, notify executives

Best Practices

1. Use Automation Wisely

Start with simple rules and gradually add complexity
Test rules in dry-run mode before enabling
Monitor execution logs regularly
Avoid circular logic that triggers infinite loops

2. Set Realistic SLAs

Base SLA thresholds on historical team performance
Aim for 90%+ compliance rate
Adjust thresholds quarterly based on data
Consider different SLAs for customer tiers

3. Implement Multi-Level Escalation

Level 1: Escalate to team (70% of SLA)
Level 2: Escalate to manager (85% of SLA)
Level 3: Escalate to leadership (95% of SLA)

4. Leverage Tags for Organization

Use consistent tagging conventions
Common tags: bug, feature-request, documentation, training
Technical tags: api, ui, performance, security
Process tags: needs-review, waiting-external, blocked

5. Monitor Key Metrics

Track these metrics regularly:

SLA compliance percentage
Average first response time
Average resolution time
Ticket volume trends
Escalation frequency
Top ticket categories

6. Document Workflows

Create internal documentation for common scenarios
Use templates for frequently sent responses
Maintain knowledge base of solutions
Document escalation paths clearly

Permissions

Ticket operations require specific permissions:

Permission.readSupport - View tickets
Permission.writeSupport - Create, update, delete tickets
Permission.manageSettings - Configure SLA, automation, escalation

API Reference

For detailed API documentation, see:

Core Concepts

Advanced Features

Integrations

Support

Need help with the ticketing system?