You Can’t Always Outwork the Requests! (How to Reduce an Overloaded Queue)

We’ve all been there—that moment when you realize you’ve bitten off a little more work than you can handle. Interestingly, the more you increase your skill level, the more often you find yourself in this situation. It stands to reason; people like to assign work to competent and talented people.

It’s common for talented designers and developers to find themselves with more requests than they have time to handle. In these situations, it’s often the natural tendency of the maker to try to outwork the requests. You simply rely on your well-developed individual talent and power through.

This strategy works extremely well in the short term. You keep everyone happy, you feel the rush of adrenaline from completing the heavy workload, and you’re praised for your efforts. You’re the hero.

The dilemma is that it’s exhausting to always be the hero, and many times putting yourself in position to be the hero is a recipe for disaster.

Time is a zero sum game, and sometimes you just don’t have enough time to outwork the requests. If you find yourself in this type of situation, I’ve realized that the most important thing you can do is to fight your natural instinct to work harder.

This momentary pause allows you to take a step back and ask the fundamental question that could change the trajectory of the potential oncoming death march. That simple question is: Do I really understand all the constraints?

Once you’ve answered that question, you can investigate the following three options to focus and ultimately reduce your overloaded work queue.

1. Reframe the Requests

I’ve found that, many times, people’s requests can be reframed with creative compromises around scope. For example, is it possible to implement a smaller thing now to hit a short-term objective, then add the bells and whistles later? Fully understanding the request constraints help you better identify what the “smaller thing” can be.

Sometimes, it’s possible to reframe the request completely. For example, I know that we’re looking to implement X, but if we were to implement Y instead, it would achieve the same goals for less effort. Once again, knowing the constraints allows you to intelligently manipulate the reframe lever.

2. Prioritize the Requests

This one sounds obvious, but it’s important to review. I’ve found that many times, I’ve misinterpreted the level of priority associated with requests. It’s easy to do. You’re busy and lots of requests are flying at you fast. They all sound important, so I should work equally hard to get them all done.

This is clearly flawed logic. Not all requests are created equal. Figuring out the ones that need to happen now and the ones that can wait will help to save your sanity.

3. Get Help

When I’m busy, I tend to feel like everyone must be busy. That feeling isn’t necessarily a reality. Many times, others are available to help. This is good for two reasons:

  1. You can share some of your workload.
  2. Since you don’t want to inconvenience others with non-urgent work, you’re motivated to first understand all the constraints, look to reframe the requests, and make sure you understand the priority of requests.

Occasionally, you need to play hero to get something done, but not as frequently as you may believe. Understanding the constraints of what you’re facing enables you to potentially identify an alternative approach that won’t leave you burned out.