Technical skill gets most of the attention in IT support, but a lot of the job is writing. Every ticket is a small record of what happened, and every repeated fix is a chance to write something that saves the next person time.
These are the habits I'm working on. They aren't tied to any particular ticketing system, and they apply whether the tool is ServiceNow, Jira Service Management, Freshservice, or a shared inbox.
Why it matters
A ticket gets read by more people than you'd think:
- The next technician, who picks it up after a shift change or escalation
- The user, who may see updates and resolution notes
- A team lead or analyst, who looks for patterns across many tickets
- You, months later, when the same problem comes back
Notes like "fixed," "user OK now," or "see email" don't help any of them.
Anatomy of a good ticket
1. A specific title
Compare:
- Weak: "Computer problem"
- Better: "Outlook (classic) not opening on laptop after password change, Teams and web mail OK"
A good title names the system, the symptom, and any important context. Someone scanning a queue should be able to understand the ticket without opening it.
2. A clear problem statement
Answer the basic questions:
- Who is affected (one user, a team, a location)?
- What is happening, ideally including the exact error message (copied, or a screenshot)?
- When did it start, and did anything change around that time?
- Where: which device, which app, on or off the network or VPN?
- Impact: can they work around it, or are they blocked?
Impact and scope help set priority. A single user with a workaround and a department that can't process payments aren't the same ticket, even if the error message is identical.
3. Steps tried, with results
This is the part I think matters most. Write it as a short log:
- Confirmed issue on user's laptop; Outlook on the web works. Mailbox OK.
- Restarted Outlook; ended lingering process in Task Manager. No change.
- Started in safe mode. Outlook opened. Likely add-in.
- Disabled third-party add-in. Outlook opens normally. Resolved.
Writing down what didn't work matters as much as what did. It stops the next person from repeating the same steps.
4. Escalation notes that stand on their own
When escalating, assume the next team won't read the whole history. Summarize at the top: what the problem is, what's been ruled out, what you think is going on, and what you need from them. Attach logs or command output (like ipconfig /all) rather than paraphrasing it.
5. A resolution that explains the fix
Write a resolution the user would understand, plus a technical note for the team. Then confirm with the user before closing, when the process allows it.
6. What not to put in a ticket
- Passwords, MFA codes, or recovery keys
- More personal information than the task needs
- Opinions about the user or other teams
Tickets get read later, sometimes by people outside the team. I'd write every note as if it might be.
From tickets to knowledge-base articles
When the same fix shows up in several tickets, it probably belongs in the knowledge base. The Consortium for Service Innovation publishes a methodology called Knowledge-Centered Service (KCS), built on the idea that knowledge should be captured and improved as part of solving problems, not saved for a separate documentation project [1][2]. I'm still learning it, but the core idea makes sense to me: the best time to write the article is while the fix is fresh.
A simple KB article template
Title: Phrase it the way a user or technician would search for it, for example "Teams shows 'We're having trouble loading your messages'."
Applies to: Platform, app, and version, if relevant (for example, "new Teams on Windows 11"). This keeps people from following steps meant for a different version.
Symptoms: What the person sees, including exact error text.
Cause: Only if it's known. "Unknown" is a fine answer.
Resolution: Numbered steps, one action per step. Mark which steps need admin rights and which a user can do.
If this doesn't work: Where to escalate and what information to include.
Owner and last reviewed date: Someone has to own the article, or it slowly goes out of date.
Tips for KB writing
- Write for the reader's level. User-facing articles need plain language and screenshots. Internal technician articles can be shorter and more technical.
- Use exact menu names and paths, and check them against the current version. Software interfaces change, and an article that was right two releases ago can send people down the wrong path.
- Link to vendor documentation instead of copying long passages from it. The vendor page will be updated; your copy won't.
- Retire or update stale articles. An outdated article can be worse than none, because people trust it.
Closing thought
Good documentation is a form of customer service, both to users and to teammates. A clear ticket helps the next person, and a good KB article keeps helping long after the ticket is closed.
Sources
- Consortium for Service Innovation, "KCS": https://www.serviceinnovation.org/kcs/
- Consortium for Service Innovation, "KCS v6 Practices Guide": https://library.serviceinnovation.org/KCS/KCS_v6
I'm Rıza Korkusuz, an IT support professional in San Diego. I write these notes to organize what I'm learning about desktop and service desk work. More at rizakorkusuz.com/it-support and github.com/rizakorkusuz.