Why doesn’t product ‘X’ just add this feature? It seems so simple.

Feature request may seem simple, in reality they are not.

I get it; I use software all the time, and sometimes it is the worst. I want those 'simple' features! They would improve my experience, and I would feel more powerful.

If you've ever worked on a complex product with dependencies or legacy systems, your heart beats faster when you hear customers say: 'just do this, just add that line of code.' There is rarely a 'just' moment when it comes to building products, and when you find that rare silver bullet, it is glorious.

When you work on a simple product or isolated feature, you don't have to think about the more extensive system or the ripple effects your decisions cause. You are connecting it to a handful of other features, not hundreds. When you add layers to a system, simple features aren't simple.

I love feature requests. Often they are great ideas and make total sense to implement. When I want a feature, I think about how it impacts my workflow, my specific task. I am not thinking about how a solution for my particular need would affect the rest of the product or customers who use that product. 

When I think of a feature, I present a problem: 


  • I want to edit a document at the same time as my teammate. 

The team's considerations:

  • Does that user need different permissions than you? Can they make edits or only suggest changes?
  • What are their default permissions?
  • Who owns the document?
  • What happens when another user deletes the document?
  • Can they share that document with other people?
  • What happens when they delete something you wrote?
  • Does your current infrastructure support document history and backups? How do you prevent conflicts within the document?
  • Does someone need to be logged in to edit the document with you?
  • ...

You can see where I am going. Although the example is rather complex, it illustrates that one request in a complicated system requires hundreds of product decisions and trade-offs. 

So why don't the features I request get implemented?

You may suggest a feature that a company wants to implement, but several reasons could prevent it from being prioritized. Here are a few:

  1. Timing: A team may not have the correct foundation to build your feature. Or they may need to design a build another feature to make your feature work in the system.
  2. Impact: You may have a valid request specific to how you use the product. But if your needs don't correspond with the needs of the broader customer base, it might not get prioritized.
  3. Business priorities: Businesses are trying to stay in business. Sometimes they need to prioritize work that helps grow the business.
  4. Product strategy. The feature may not be in line with what the vision is for a particular product. 
  5. Focus. There isn't enough time in the day to build everything. Even large organizations like Apple and Google have to prioritize initiatives for their teams. Smaller startups have to be even more strict. 
  6. Complexity. Mix this one with 'impact'. If few people would use the feature and it is complex to build, it is unlikely to make a roadmap.
  7. Ripple effect. Sometimes features can negatively impact other areas of the product that are important to other customers and the business. 
  8. Role out and support. How does this feature impact the level of support customers will need? If the feature changes how the product works, the company will need to educate its existing customer base. That is potentially a colossal task.
  9. Politics. People are people. Every organization has individuals with agendas and priorities. Many times they compete.

Don't let me discourage you from submitting requests. Please continue to ask for more things. We makers need them! There are always engineers, designers, and product managers begging and advocating for these internally. I promise we want to 'just' implement a feature, but it rarely is a 'just'.