Ticket Notes: What a Good One Looks Like (With Before-and-After Examples)

A client calls on a Thursday because the shared mailbox stopped syncing again. The tech who picks up opens the ticket from last month and finds one note: "Fixed Outlook. Closed." Nobody knows what was fixed, on which machine, or whether it was the same problem. So the tech starts from zero, the client explains it all a second time, and the 20 minutes spent last month buy nothing.

That is what a bad ticket note costs. Not a style problem, a rework problem.

A good ticket note answers three questions for whoever opens the ticket next: what was wrong, what was done, and where it stands now. It names the user, the device and the error, lists what was checked (including what was ruled out), states the result in one line, and says who owns the next step. It goes in the field the right reader will see: the customer-facing note for the client, the internal note for your techs, the resolution field for whoever reviews the ticket later.

The rest of this post is about the part most guides skip: a ticket note has more than one reader, and most bad notes come from writing for none of them.

The three readers of every ticket note

Every note on an MSP ticket gets read by up to three people, at three different times, for three different reasons.

The next tech, hours or days later. They need state, not story. What is the user's exact symptom, what has been tried, what is still untested, and is anything waiting on someone? If they have to call the user to find out what you already knew, the note failed.

The client, today or at month end. Depending on your setup, they see notes in the portal, in email, or as line items on an invoice. They need plain language and proof that work happened. They don't need your registry path.

The reviewer, months later. A service manager in a ticket review, an account manager preparing a QBR, or you, defending a disputed invoice. They need to know what the time bought and whether the fix held.

"Fixed Outlook" fails all three. A wall of pasted PowerShell output fails the client and the reviewer. A polite customer email with no technical detail fails the next tech. The fix is not one longer note. It's the right content in the right place.

Put each note where its reader looks

Every major PSA separates customer-visible notes from internal ones, but each one does it differently, and the defaults bite people.

ConnectWise PSA. A ticket note is flagged as Discussion, Internal or Resolution. Discussion is the customer-facing record, and depending on the ticket's "Send Notes as Email" settings, a Discussion note can be emailed to the contact the moment you save it. Internal is for your team. Resolution is where the fix belongs, and it's the field reviewers and reports go looking for. Time entries carry the same three choices, so a time entry's note can land in any of them.

Autotask. Every ticket note has a publish setting that decides who can read it, such as all Autotask users or internal users only. "All users" is not the same as "visible in the client portal": portal exposure also depends on how your portal is configured. Check before you assume. Autotask's own help covers adding a note to a ticket.

HaloPSA. Notes are actions on the ticket, and each action can be hidden from the end user. Your action types decide the default, so a tech who picks the wrong action can publish an internal note without meaning to.

Syncro. Ticket comments are either public or private (hidden). A public comment can also be emailed to the customer. Syncro documents this under ticket communications.

The practical rule: decide per note type where it goes, write it into your SOP, and set the PSA defaults so the safe choice is the easy one. Internal by default is safer: a tech who meant to post internally and published to the client is a worse day than one who has to re-post a note as customer-facing.

A bad note and a good one, side by side

Here is one example ticket, written two ways. The details are illustrative.

The note most desks get:

Called user. Fixed Outlook. Working now.

The same work, written for the next tech (internal):

Issue: Dana in accounting, laptop ACCT-LT07. Outlook not syncing the AP shared mailbox since Monday. Own mailbox fine.

Checked: OWA shows the shared mailbox current, so the server side is fine. Mailbox permissions correct in Exchange admin center. OST for the shared mailbox at 49.8 GB, close to the default 50 GB limit.

Ruled out: license (Business Standard, assigned), network (other mail syncing).

Fix: Turned off "Download shared folders" so the shared mailbox runs online. Synced within two minutes. Confirmed with Dana on the call.

Next: None for this ticket. If AP needs it offline again, the mailbox needs archiving. Flagged to account manager.

And for the client (Discussion / public):

Your AP shared mailbox had stopped updating in Outlook because the local copy on your laptop had grown too large. We changed Outlook to read that mailbox directly from the server, and it is updating normally again. No action needed from you. We've noted that the mailbox is very large and will follow up separately about archiving.

And the resolution line:

Shared mailbox OST near size limit; switched shared mailbox to online mode. Resolved, confirmed with user.

Notice what each version carries. The internal note names the device and the evidence, so the next tech can skip straight past the dead ends. The client note explains the cause in one sentence and says what happens next. The resolution line is short enough to scan in a report. None of them contains a password, an MFA code or a recovery key, and none of yours should either.

If you want a fixed template for the internal note, our MSP SOP templates use four parts: issue, troubleshooting, resolution, follow-up. The example above follows it.

Three tests before you save

You can check any note against three quick questions. Each one maps to a reader.

  1. The cold-start test (next tech). Could a tech who has never seen this client continue the work without calling the user? If the note says "tried the usual," it fails. Name what you tried.
  2. The invoice test (client). If this note showed up on the client's invoice next to the time it took, would the time look justified? "Troubleshooting, 1.5 hours" invites a dispute. "Rebuilt the mail profile, cleared the cached credentials, confirmed sync with Dana" does not.
  3. The six-month test (reviewer). If this issue comes back in six months, does the note tell you whether it's the same problem? That means the cause, not just the action. "Rebooted" is an action. "Print spooler hung after a driver update" is a cause.

A note that passes all three is rarely longer than a dozen lines. Length is not the goal. Specifics are.

Where ticket notes actually go missing

Most advice on ticket notes is about writing better notes. In practice, the bigger problem is notes that never get written at all, and they cluster in the same places:

  • Phone calls. A tech resolves something in a six-minute call, hangs up, and the next call is already ringing. The fix lives in the tech's head and nowhere else. If you only audit the notes that exist, you never see this.
  • Quick fixes between tickets. A password reset done "while I had you on the phone" about something else, with no ticket at all.
  • Remote sessions. The work happened in a remote control tool, and the PSA only shows the ticket moving from New to Closed.
  • Handoffs. Tier 1 escalates with "see above," and "above" is the user's original email.
  • After hours. The on-call tech fixes it at 11 p.m. and writes it up the next morning, from memory, or not at all.

You can spot this in your own PSA without any tooling. Pull last week's closed tickets and count how many have time entries but no note beyond the title, or a resolution field that just says "resolved." Then compare your phone system's inbound call count for a day against the tickets and notes logged that day. The gap is your missing documentation, and it's also usually your missing billable time.

Members of r/msp have argued about this for years (one long thread on writing service ticket notes), and the advice is consistent: write it while you're still on the ticket, not at the end of the day. That is good advice that breaks the moment the queue gets busy, which is exactly when notes matter most.

Should AI write your ticket notes?

For the notes that go missing, yes, with guardrails. A support call already contains the issue, the troubleshooting and the outcome; the tech just said them out loud. Writing them down again is the step that gets skipped. An AI that transcribes the call and drafts the note removes that step.

What to hold an AI-written note to:

  • The same three tests. An AI note that summarizes the conversation ("The user called about Outlook and the technician helped") fails the cold-start test as badly as "Fixed Outlook." It has to name the device, the error and what was ruled out.
  • The right field. An AI writing to the customer-facing field is a bigger risk than one writing internal notes. Start internal.
  • No secrets. If a password or code is read out on a call, it must not end up in the note.
  • Skip what isn't work. A voicemail or a transfer shouldn't produce a note.

We go deeper on checking AI drafts in AI call summary: how it works and what to check.

How Vight writes ticket notes

Vight pulls recorded support calls from your phone system, transcribes them, matches each call to the right client and ticket, and writes the note for you in ConnectWise, Autotask, HaloPSA or Syncro.

The IT Support Summary it writes has four sections, issue, troubleshooting, resolution and follow-up, and marks whether the call was resolved, pending or escalated. You set how detailed each section is on a 0 to 5 scale, so you can keep troubleshooting detailed and follow-up brief, or hide a section entirely. Calls detected as voicemails or transfers are skipped. Vight creates the time entry in ConnectWise, Autotask, HaloPSA or Syncro, and in ConnectWise you can choose the work type and write the summary into the Discussion, Internal and/or Resolution fields, which is exactly the reader split described above.

For work that happens on screen rather than on the phone, Vight's Work Notes Agent (in beta) captures a technician's work session on a ticket and turns it into a step-by-step work note and time entry for the tech to review.

If you want to see what those notes look like on your own tickets, book a demo and bring a ticket your team argued about.

Related reading: call logging software for MSP ticket workflows, ConnectWise AI, Autotask AI and HaloPSA AI.

Common questions about ticket notes

What should a ticket note include?
The user and device, the exact symptom or error, what was checked and changed, what was ruled out, the result, and the next step with an owner. If there is no next step, say "none."

What is the difference between an internal note and a customer-facing note?
An internal note is for your technicians and can include technical detail, device names and dead ends. A customer-facing note is what the client sees in email, the portal or on an invoice, and should explain the problem and outcome in plain language. In ConnectWise these are Internal and Discussion notes; in Autotask the publish setting decides; in HaloPSA it's whether the action is hidden from the user; in Syncro it's a private or public comment.

How long should a ticket note be?
Long enough to pass the cold-start test: a new tech can continue the work without calling the user. For most tickets that is five to twelve lines. Pasted logs belong in an attachment, not the note.

Should every phone call get a ticket note?
Every support call should end up on a ticket, either as a new ticket or a note on an existing one. Calls are where documentation is most often lost, because the tech moves straight to the next call.

Can AI write ticket notes?
Yes, from call transcripts or recorded work sessions. Hold AI notes to the same standard as human ones: specific, in the right visibility field, and with no passwords or codes. Start by having AI write internal notes and review them before letting it post anything the client sees.

Should ticket notes include passwords?
No. Store credentials in your documentation platform, such as IT Glue or Hudu, and reference the entry in the note.

See Vight document every call and ticket in your PSA