Staying Focused and Understanding Trade-offs
In software development and in life
While this post is focused on software development, I have also found these ideas useful in other contexts. In fact, I have developed these perspectives primarily outside of a software context.
Every software project comes with a unique set of challenges. To ensure success, it’s important that your project has a clearly defined purpose.
Narrow Your Focus — Separate The Signal from the Noise
In most contexts people talk about goals in general terms: “I want to build an app that changes the world”. However, when it comes to execution, there are some common deficiencies which trip people up:
- Difficulty determining the steps necessary to execute efficiently
- Inability to accept sub-optimal, but adequate and necessary, solutions
- Struggling to change course and discard plans that are no longer valuable or necessary — even if that means most or all of them.
Smart engineers get stuck on seemingly important steps all the time. It can be incredibly distracting when you care deeply about specific execution or implementation, but the fact is most cases are not life and death in software! Often, deliverables that are no longer necessary or relevant can dominate and derail the overall project or goal of the company. When engineers over-invest in details which are no longer necessary, or are inessential to the objective, valuable time and resources are wasted, jeopardizing the project’s success. Recognizing when ‘important’ steps have become ‘distracting’ steps, is an important super power.
Note: it is important to understand that ‘distracting’ tasks are not neutral — they are always in the way of fixing real problems.
Prioritizing tasks and understanding the difference between signal and noise go hand and hand — effective prioritization has strong dependency on a clearly defined objective.
Difficulties with prioritization often stem from a lack of understanding of how the feature or task relate to the overall project objective. This is a good example of poor prioritization: feeling the need to build your own framework so that it meets the exact needs of the application in the most efficient way possible, before you even have an MVP or have validated the market for the thing you are building. Unless your product is web frameworks, it would be misguided to spend that energy on it this early. There isno need to for an infinitely scalable framework if you only have 4 users.
Task prioritization should be ordered by value generated over effort necessary to deliver on the task, with varying value weight placed on short term vs. long term implementation.
For a brand new startup, prioritizing longevity is important and writing bad code is never a good idea, but spending weeks polishing your backend code base that already works, while your UX is suffering due to poor front-end design, is poor prioritization. On the other end of the scale, a large company with high traffic volume failing to address scalability over minor UI changes with no tangible value generated, is also poor prioritization.
The majority of priority decisions boil down to trade-offs. Remaining intentional about keeping your overarching goals in mind and understanding the implications of the trade-offs you make is fundamental to stable growth.