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:
| Impact | Urgency | Priority |
|---|---|---|
| High (multiple users / critical biz) | High (immediate) | P1 – Critical |
| High | Low | P2 – High |
| Low | High | P3 – Medium |
| Low | Low | P4 – 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.
- Identify the problem: Gather info, question the user, reproduce if possible.
- Establish a theory of probable cause: Consider the obvious (physical layer, recent changes).
- Test the theory: Change one thing at a time and observe.
- Establish a plan of action: Outline steps, consider impacts.
- Implement the solution (or escalate).
- 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