I’ve been building software for 12+ years now. During that time I’ve been a part of various projects – from small websites to massive applications spanning multiple years. I’ve also founded several MVP (minimum viable product) launches.
As I reflect on my own experiences, plus experiences of my peers, I’m realizing a consistent theme in successful projects and MVP launches.
Keep things simple.
Wow. Mind blowing, I know! Why the heck did I take time to write an article about this?
Because 99% of the time we make it complex.
Yep. Ask anyone you know in software development. We ALL submit to complexity at some point. This comes in so many shapes and forms:
- We waste time creating the “perfect” founding team.
- We spend huge amounts of energy on the “right” go-to-market strategy.
- We drastically overthink the “scalable” technology and tools we should use.
- And my favorite – we add that last critical feature [or 7 of them] that the product MUST have to be “ready.”
- etc…
Look at all the words I highlighted above. Perfect, right, scalable and ready. These words all suggest closure and/or realization of a final solution. And that’s exactly the problem – none of them deal in absolute context. They are all relative.
- Nothing is ever perfect, especially humans, which includes your team.
- There is no right strategy for anything. It’s always contextual to what you’re solving and who you’re serving. And more often than not, your strategies in software development change constantly.
- Technology doesn’t scale. People actually scale things. Read all about that here.
- And of course, there is never a specific time when your product is ready. It’s ready when you decide to launch it.
More importantly, these all take you from simple to complex in a matter of seconds.
So what can we learn from this?
If you embrace simplicity you will iterate faster, fail quicker, and learn a lot more effectively. You will guard your product from all the pitfalls that complexity introduces. If you stay the path, you will introduce complexity if [and when] it is absolutely necessary.
Advantages of Simple
Starting to see a trend here?
Simple is just easier to manage and execute. Period.
By embracing simplicity you will also establish a baseline of saying “No.”
Why Saying No is Vital
Keeping things simple is analogous to saying, “No.” In other words, it’s much easier to say yes to things vs saying no. So your default answer to anything should always be no. For example:
Should we add that “nice-to-have” team member who could do x, y and z?
NO. Spread responsibilities out amongst the existing team and figure it out.
Should we revisit the go-to-market strategy again?
NO. Pick a channel, test your experiment, and record the results. Then move onto the next.
Should we spend time tinkering with various tools and technology?
NO. Build with what you know and get the MVP done.
Should we add that last feature that [team member] thinks is essential?
Absolutely Not. Start with a simple launch and add more later.
All of these “no’s” guard you from complexity and ensure that you only invest time and energy into things when they deserve resources. This also gives your occasional “yes” so much more value and impact when you do decide to take action.
Key Takeaways
Keep things simple to improve your speed and efficiency. Only introduce complexity (more) if and when it becomes relevant. And finally, say “no” as your default to just about everything.
Ali Jafarian
Ali is a father, husband and serial entrepreneur with a deep drive to create. He writes, records, codes and builds things to inspire the artist in all of us.
Discussion