How an entrepreneur’s mindset can help programmers design better software
You clicked on this article (which is a big success for me because this is my first story) — but the point here is not about my writing endeavors, but rather about programmers. And, more specifically, how an entrepreneur’s mindset can change their approach to solving problems and focusing on the big picture.
Since you are reading this article, most probably you are a programmer just like I am. We have probably gone through some similar programming situations and made the same mistakes in our programming life that would make us completely understand each other even though we have never even met.
How do I know this?
Let me try something out. I will list some common mistakes that I have made throughout my programming days. While you are reading this list, if you occasionally nod your head or have your mind blown saying: Hell yeah. I have done the same! then we are not strangers but rather two programmers who have gone through the same stuff. Let’s start.
Have you ever:
- Acted before actually thinking and understanding the problem?
- Assumed a feature was needed?
- Thought that this new feature implementation would be a piece of cake?
- Created imaginary problems and tried to solve them?
- Published code without testing?
- Spent too much time on unnecessary things within an overall project?
- Done everything by yourself (hero programmer)?
- Applied the wrong task separation and management?
- Tried to make the first version perfect?
- Underestimated the scope of the project and the amount of time that would be required to complete it (Deadline nightmare)?
Are you still nodding?
The point is that it does not matter which programming language you know or use, what kind of programmer you are, and how vast your experience is. The point is that you are a programmer, and like all of us you can be easily trapped in one behavior pattern which looks efficient at the beginning and makes you feel smart but that eventually turns into a mess.
Been there. Done that.
As every programmer has, I made the same mistakes in my early programming life while working on many different software projects with various other programmers.
Once I reached a certain point where, instead of repeating the same mistakes, I started recognizing behavior patterns, I realized that the majority of programmers were working by the same pattern.
It was a breakthrough for me.
Can you imagine? Instead of spending quality time building great software, we are actually trapped in our own behavior patterns that lead us to lose time day by day and code by line of code.
I decided to try to change this pattern and learn from my mistakes. With the power of will and a bit of luck, I somehow managed to do so.
Start small. Think big.
What was my first action?
I started learning from the best.
I spent every day spending every free minute reading articles, books, watching videos and following best practices on how to improve my coding style and not make the same mistakes again.
I noticed a pattern: having great programming skills (even though they are super duper important to have) is not enough when it comes to minimizing these mistakes. Rather it’s something outside of the code.
To avoid the most common programming mistakes that lead to nightmare deadlines, unnecessary code lines and losing time, you need to expand your perspective and point of view. Instead of just thinking about the software you code only from your perspective, as a programmer, you should look at the software you design from a much bigger perspective.
This bigger perspective means to focus on the main idea, the purpose of the software, and not only on the core functionality.
I realized that we should never forget to ask ourselves: Why are we coding this software in the first place?
What does this mean?
Programmers tend to lock themselves inside the software they build, which usually leads to shrinking their focus only to the lines of code.
When this happens, you tend to miss the main point which is the purpose of the software. You are building this software to help your users by solving their problems and making their lives easier. When you keep this purpose in your mind while you are coding, you will be able to reorganize your development process in a more efficient way. Instead of being trapped inside the code, you are now being guided by the main idea of the software which will give you the ability to cut unnecessary things and focus on the core concepts.
When you put things this way, suddenly coding style isn’t the only important thing.
Beyond the code
While working in a company and leading a team of developers, I also started building the side project that eventually taught me some major lessons on how to reorganize my development process. I went from a code-only perspective to a software purpose perspective.
How I started was very simple. It is maybe ironic, but to improve my code, the first thing I did was to escape my code. I had to see beyond the code.
Maybe it sounds weird but it actually works. While working as a programmer, I also had the tendency to focus on the code functionality until I started building my own project.
While designing my own software, I started reading many articles about how entrepreneurs should approach problems in order to solve them and how they can grow their business with limited resources and limited time.
I saw that the strategies entrepreneurs follow can help programmers change their mindset and help them develop better and bug-free software.
I went and applied the same concept at work and it showed great results.
Let’s take a closer look at each common mistake made by programmers and see how entrepreneur mindset can help us avoid them.
1. Acting before thinking about the problem
Have you ever jumped straight into coding instead of thinking about the problem you are trying to solve? Without considering all the requirements of the software? Yeah, I have, too. Then we realize in the end that we chose the wrong tools and wrong architecture to code the software.
As a result, we face even bigger problems than the problem that we tried to fix in the first place. These problems come in the form of complex design, which makes the solution unmanageable and results in hard to maintain program structures.
So now, let’s try to approach this problem from an entrepreneur’s perspective.
An entrepreneur would do deep research to understand the market and problems that the customers experience. They would know that without exactly understanding the problem and analyzing it from each perspective, eventually, it would lead to bigger problems like wasting time and resources. After all, with already limited time and resources, wasting time on unnecessary things is definitely not part of their plan.
Main point: Don’t act before understanding the problem.
2. Assuming a feature is needed
If you don’t understand the exact expectations and features that are required by the software you need to build, you might misunderstand the concept and invent an unnecessary feature which is totally irrelevant to the overall software’s purpose. So what happens is that you waste your time on that unnecessary feature while missing the core feature’s implementation.
From an entrepreneur’s point of view, this is not acceptable.
While building software you should first focus on the feature that solves the customer’s problems. By listening to the customer’s voice and analyzing their needs, you can then build software from essentially required features while others come later on.
Main idea: Don’t assume. Question everything.
3. Assuming new features will be easy to implement
As programmers, we have a keen ability to underestimate the feature implementation process. Sometimes we believe that we know how to solve the problem without even thinking about it.
Again — wrong.
This kind of behavior leads to missing deadlines because nothing is easy and everything has to be planned carefully. An entrepreneur would know that without having a clear implementation plan, invisible problems may appear which can eventually lead to many other troubles.
Main idea: Never underestimate the problem. Think, plan and than act.
4. Creating imaginary problems and trying to solve them
As programmers, we like challenges 🙂 (you know what I mean).
Sometimes we like to implement code that has no other purpose but to satisfy ourselves and prove to everyone that we could overcome this challenge.
There are moments when we even try to predict features that will solve imaginary problems that we created.
While programmers are inventing imaginary problems, entrepreneurs are avoiding them. Simple enough.
They would focus on the problems that actually already exist and try to solve them as soon as possible. In that way, they gain the ability to invest their time in things which are essential for their business.
Main idea: Don’t predict future problems. Focus on the ones you already have.
5. Publishing code without testing
Do you remember the last time you pushed some code to production without testing it?
Sometimes we make this mistake because we are excited about our code. Sometimes even senior programmers can make this mistake. Many programmers see testing as a burden, and after coding, it’s easy to skip it. But what they are not aware of is that skipping this step will create troubles for them in the future: instead of being productive, they will become bug hunters with sleep deprivation.
When we look at entrepreneurs, they tend to verify and test everything before execution. This is because they don’t want to ship a product that is not wanted or needed by their potential customers. Before shipping, they always test whether the problem they are trying to solve really exists and if there is a market for that product or not. In this way, they will minimize the possibility of failure.
Main idea: All code lines must be executed at least once.
6. Spending too much time on unnecessary things
Generally, this happens when programmers are obsessive about a certain issue. Doesn’t matter if this issue is important or not. They try to overcome this issue again and again because — as mentioned above — they like challenges. In the end, maybe they will succeed, but at what cost?
The problem? Determining whether the issue really needs to be solved. If they stop to question it and see the big picture, they would never waste their time fixing an issue that is not important.
On the other hand, entrepreneurs know that they don’t have the luxury to waste their time on unnecessary things. Basically, they question everything and make their priorities straight.
Main idea: Don’t waste your time. Use it wisely.
7. Doing everything by themselves
In this paragraph, I am not talking about programmers who work in well-organized companies. If you have a good team leader who knows how to delegate jobs, it’s not an issue. But in some companies — especially small ones or startups — programmers have a tendency to do every task by themselves. They believe that if they delegate their tasks to other team members they will make mistakes. Basically, they don’t trust them.
Eventually, they become overloaded with work and the development process starts to become very slow.
Entrepreneurs are typically well aware that they can’t do everything by themselves. They tend to create an environment based on trust where everyone can ask for help. Task delegation and working in teams can lead to an increase in work efficiency.
Main idea: Trust your team. Don’t forget that everyone needs help.
8. Wrong task separation and management
I believe that the task creation process is one of the most important steps in designing better software. Instead of separating a certain project into smaller tasks, programmers or team leaders sometimes group all tasks into a single project.
In this way, when they start with task implementation, the task itself can look bigger than it really is and they don’t know how to approach it or where to even start.
On the other hand, if you separate one big task into smaller tasks, you can always choose to start with small steps. Going step by step and completing each subtask will lead to completing the big picture and solving the task fully in the end.
Separating a task into subtasks helps in solving complex problems and allows you to manage tasks in a more efficient and simple way.
I believe that every entrepreneur has a “start small” mindset.
Main idea: Start small than extend.
9. Trying to make the first version perfect
Programmers often try to implement everything in the first software version. They believe that without giving everything to customers in the first version, those customers will be disappointed and they will not like the product.
This approach leads to a deadline nightmare and delay of the first release.
However, entrepreneurs tend to strongly believe in the feedback cycle. They follow the principle of “Build it, ship it, iterate it.” They know that they have to ship their product into the market as soon as possible. Once they release the first version, they will listen carefully to their customers and analyze their feedback. In this way, they will make their product better and avoid the implementation of unnecessary features.
Main idea: Build it, ship it, iterate it.
10. Underestimating the scope of the project and time required to complete it (Deadline nightmare)
How many times have you felt pressure and stress because of a missed deadline?
Did you ever ask yourself why you missed this deadline?
I believe, as a programmer, deadlines have always been a nightmare for us. Generally, we tend to underestimate the scope of the requirements which brings us to a point where we can’t accurately estimate the required amount of time needed to complete the project.
I believe that 80% of the development process should be dedicated to establishing software requirements and designing a feature list and appropriate architecture to build the project. The other 20% percent should be dedicated to coding.
However, this is easier said than done. In practice, this is always a challenge for a team of developers.
To a person with an entrepreneur mindset, time is the most valuable resource. Therefore, they define their business scope carefully and estimate their project time in a more accurate way.
Main idea: Everything takes longer than you think.
I’ve seen many programmers who had to rewrite their software from scratch because of mistakes made in the early stages of the development process.
Re-coding software that was created by bad development processes is a waste of time.
Imagine a scenario where the development process has been planned and organized in a better way from the start. Now instead of rewriting the software, programmers could dedicate their time to developing new products or improving existing ones.
I always believe that if we can focus on the purpose of what we are doing and why we are doing it, everything will be much clearer for us. I,f we always keep the big picture in our mind we will develop better and higher quality software that will be designed to fulfill a certain purpose.
Don’t waste your time. It’s precious and your most valuable resource.