High Contrast Dyslexic Font

Ticket Handling & Support Best Practices

Master the full lifecycle of a support case – from opening to closing – with practical tips for prioritisation, live chat, troubleshooting, and using Jira.

Opening Cases

Gather info, set SLA, classify urgency

Prioritisation

Impact × Urgency – triage effectively

Closing Cases

Verify fix, document, follow‑up

  • Capture key info upfront: User name, contact details, device, error messages, and steps to reproduce.
  • Set expectations: Give a realistic ETA and explain the next steps.
  • Assign severity/priority based on impact (how many affected) and urgency (how soon needed).
  • Use a template in your ticketing system (Jira, ServiceNow, Zendesk) to ensure consistency.
  • Check for duplicates – link to existing tickets to avoid duplicate work.
Pro Tip: The "5 Whys" technique helps uncover the root cause – ask "why" five times to get to the core issue.

Use a Priority Matrix based on Impact and Urgency:

ImpactUrgencyPriority
High (multiple users / critical biz)High (immediate)P1 – Critical
HighLowP2 – High
LowHighP3 – Medium
LowLowP4 – Low
  • P1: Service down, data loss, security breach – immediate response, escalate if needed.
  • P2: Major functionality impaired but workaround exists.
  • P3: Minor issue, single user, can be scheduled.
  • P4: Requests, questions, or low-impact issues.
Remember: Prioritisation is dynamic – re‑assess if the situation changes (e.g., more users affected).

  • Be concise but warm: Use short sentences, but start with a friendly greeting.
  • Use canned responses for common issues, but personalise them.
  • Set clear expectations: "I'll need about 2 minutes to check that."
  • Use screen‑sharing tools (e.g., TeamViewer, AnyDesk) when needed – always get consent.
  • Type while listening: Take notes during voice calls – they become ticket notes.
  • End with a summary: "Just to recap, we've done X and the issue is resolved. You can close the ticket if everything is fine."
Empathy in chat: Use "I understand" and "Thank you for your patience" to maintain rapport.

  1. Identify the problem: Gather info, question the user, reproduce if possible.
  2. Establish a theory of probable cause: Consider the obvious (physical layer, recent changes).
  3. Test the theory: Change one thing at a time and observe.
  4. Establish a plan of action: Outline steps, consider impacts.
  5. Implement the solution (or escalate).
  6. Verify full system functionality and document everything.

Remember the golden rule: Never make multiple changes at once – you'll never know what actually fixed it.

Use the OSI model as a guide: start at Layer 1 (physical) and work up.

Key commands: ping, tracert, ipconfig, nslookup – they are your first line of defence.

  • Verify the fix: Confirm with the user that the issue is resolved.
  • Document the solution: Write clear, concise notes for the knowledge base.
  • Follow up: Send a brief email or message asking if everything is still working after 24 hours.
  • Close with a summary: In the ticket, include what was done, what was the root cause, and any preventative measures.
  • Auto‑close rules: If the user doesn't respond after a set period (e.g., 3 business days) and the issue is suspected fixed, the system may close it with a note.
  • Never re‑open without new evidence: If the user reports the same issue later, open a new ticket linked to the old one.
Rule of thumb: "Closed cases will not be reopened." – always create a new ticket if the issue resurfaces.

Whether you use Jira, ServiceNow, or Zendesk, these principles apply:

  • Statuses: New → Assigned → In Progress → Pending (waiting on user) → Resolved → Closed.
  • Linking: Link related tickets (e.g., duplicates, parent/child issues).
  • SLAs: Track response and resolution times – always update the ticket with time spent.
  • Comments: Keep a professional, factual log – avoid emotional language.
  • Search before creating: Always search for existing tickets to avoid duplicates.
  • Knowledge base integration: Link solutions to KB articles to help users self-serve.
Pro tip: Use Jira automation to send reminders, escalate stale tickets, and auto‑close after resolution confirmation.

  • Rule #1 – Users lie. It's not malicious, but they may forget or omit details. Always verify.
  • Rule #2 – Document everything. Even if it seems trivial, it helps others and builds your knowledge base.
  • Rule #3 – Escalate when stuck. Don't waste hours on a single ticket – use the team.
  • Rule #4 – Keep learning. Technology evolves – dedicate 30 min daily to reading.
  • Rule #5 – Be kind. A calm, patient approach defuses most situations.
Remember: Your job is not just fixing tech – it's fixing the user's day.
Quick Reference – Case Lifecycle
🟢 OpenGather info, set priority
🟡 In ProgressTroubleshoot, test, update
🔵 PendingWaiting on user/third‑party
✅ ClosedVerified, documented, followed up