The Junk Drawer Effect: Why Bundled Tickets Kill Flow

I’ve spent decades looking at service boards, and I can tell you exactly which tickets are killing your team's morale. It’s not the complex server outages. It’s not the difficult migrations.

It’s the ticket titled: "A few things..."

I created the Ten Golden Rules of PSA to help IT leaders stop drowning in their own operations. These aren't friendly suggestions. They are constraints designed to force reality back into a system that naturally drifts toward chaos.

If Rule #1 is about making sure work is recorded, Rule #2 is about making sure work is solvable.

Rule 2: One Issue, One Ticket. No Exceptions.

This rule exists because service organizations have a chronic misunderstanding of what an “issue” actually is.

To most people—especially your clients—an issue is simply everything they communicated in a single interaction, whether it’s one email, one phone call, or one conversation where they dump a laundry list of grievances. From a human perspective, bundling these things into one ticket feels polite, efficient even. Like you’re reducing clutter.

But from a systems perspective? It’s a disaster.

The System Demands Specificity

An issue is not defined by how it arrives. It is defined by how it must be resolved.

When you collapse multiple issues into a single ticket, you are forcing the system to pretend that different problems are the same. But they’re not.

For example, let’s say:

• One part of the email is a password reset (Urgent, Low Skill).
• The second part is a request for a new laptop (Sales, Procurement).
• The third part is a vague complaint about the WiFi (Complex, Troubleshooting).

These are different urgencies, with different billing rules, and different skill requirements.

When you staple these together, the system pays for this so-called “convenience.” One issue becomes dominant—usually the loudest or most scary one. The others are dragged along behind it, waiting their turn. Something simple (the password) is delayed behind something complex (the WiFi). Something billable is trapped behind something covered by your managed agreement.

The ticket looks “open,” but nobody can tell why. This is how work gets "sticky."

The Junk Drawer Effect

Bundled tickets are the primary cause of aging work that feels inexplicable.

Technicians touch them repeatedly but never finish them because "there's still one more thing." Notes get long. Context gets muddy. Something simple is delayed behind something complex. And hand-offs become painful because the next technician has to act like an archaeologist just to figure out what work is left to be done.

Eventually, your team stops wanting to pick the ticket up at all. At that point, the ticket isn’t a container for truth anymore. It’s a junk drawer.

Generosity vs. Inconsistency

There is also a subtle but damaging financial impact here. When billable and non-billable issues share a ticket, billing gets delayed or skipped altogether.

Nobody wants to split time. Nobody is quite sure how much effort went into which part. The path of least resistance is to just include it "this time." Over months and years, this erodes your margins quietly and consistently.

And here’s the kicker: Clients don’t see this as generosity. They see it as inconsistency. One month they’re billed, the next they aren’t. The rules feel arbitrary. Trust erodes—not because you charged them, but because you didn’t charge them predictably.

Preservation of Flow

This rule exists to preserve the clarity of flow. When tickets represent bundles of unrelated issues, coordination becomes guesswork and triage becomes emotional.

However, when each issue has its own ticket, the system can do what it was designed to do. One issue can be escalated while another is resolved. One can be scheduled while another waits. One can be billed while another remains included. Progress becomes visible instead of implied.

"One issue, one ticket" does not mean "one email, one ticket."

Your intake is allowed to be messy. Clients are allowed to explain things badly. That’s how end-users roll. But your job is to translate that chaos into clean units of work the system can handle.

Related tickets can, and should, be linked. This preserves context without sacrificing control. But what should never happen is merging issues simply to make the board look smaller or the admin work feel lighter.

A smaller board that hides reality is worse than a larger board that reflects it.

Organizations that adopt “one issue, one ticket” notice an immediate change. Tickets close faster, backlog ages more honestly, and your team stops feeling like they’re drowning in half-finished work.

The Bottom Line

Adopting this rule is uncomfortable at first because it exposes volume. It makes demand visible in a way that can’t be explained away. But that visibility is the prerequisite for solving the real problem.

Bundling issues doesn’t reduce work. It just hides it.

One issue. One ticket.

Anything else trades short-term comfort for long-term chaos. Stop hiding the work and start managing it.

Remember, the goal here isn’t a tidy inbox; it’s a transparent system. Unbundle the chaos and let the work flow. Because you can’t fix what you refuse to see.

_{Image by Image-Source | Envato}