“A ‘startup’ is a company that is confused about – 1. What its product is, 2. Who its customers are 3. How to make money.” – Dave McClure, Founder 500 Startups
During its journey, a tech startup has three levers of success: cost, speed, and quality.
Unfortunately, you can choose only two at a time. So, if you pick speed and cost, you might have to sacrifice quality. Or, if you chose speed and quality, it’s likely to cost you millions.
This choice of two over three leads to software entropy, which is a case of “what’s done cannot be undone,” as Lady Macbeth says, or in tech terms, you’d say,
“In a closed system such as software technology, a depleting quality of a product cannot be improved over a period of time.”
We will discuss more on software entropy, factors leading to it, and possible solutions.
Before that, it is important to understand what leads to software entropy.
Three levers of startups
Once you wade into the waters of startups, you realize that time is the most limited resource of all three aforementioned factors.
Until a startup starts seeing some traction in terms of revenue, it’s never termed a company.
To make the best use of the bootstrapped amount, a quick product usually called the ‘beta version’ and often of a “subdued quality” (compared to the goal product), is released to capture the market as early as possible.
Startups drain most of their resources to reach the market as soon as possible, putting all efforts into achieving ‘speed’, which in most ways is the most popular lever of the three.
When compared with time, the cost is tangible in every sense. It is the heartbeat of a startup.
“There are only two priorities for a startup: Winning the market and not running out of cash.”
– Ben Horowitz
The more the balance in your account, the longer you survive. During the initial phase of a startup, most of the resources are spent arranging important assets (read liabilities too) for your organization, such as paying for the office, furniture, internet, salaries, and a whole lot more.
More often than not, startups struggle to afford the top developers from industry because of budget constraints. (Also read – How to recruit on shoestring budget)
Usually, top coders or senior managers are left for later, with the intention of hiring them when money flows in.
Good work is expensive, great work is more expensive, and quality work comes at an exceptional cost.
Quality is the most difficult to achieve. Good quality requires a great amount of time and cost to attain. And this is where most startups suffer.
Most startups start with limited funds and strive to make profits as soon as possible. They aim to be production-ready and sell before they run out of capital.
Until the company is at a growing stage, an entrepreneur strives to produce rapidly and penetrate the market.
This allows these startups to acquire market share and collaborate to build on customer feedback.
Most companies start with a ‘beta-version’ which can generate some traction and fund their requirements as they move up the ladder in a market characterized by severe competition for their product.
Startups typically hire fresh developers and engineers (few have the budget to hire senior developers) who understand their requirements, have some sense of development, and can create the product with the least amount of resources.
And no doubt, these developers come at a lower cost. They are easy to mold and can often work in odd shifts.
Raghav Chandra, Co-founder/CTO, Urbanclap, says
“Quality is often viewed as a compromise on speed (longer sprints, more code writing/testing, etc.) and cost (more engineers, better quality infra, etc.). However, in the younger stages, good quality is a huge boost to speed and cost.
Quality has multiple aspects: its the architectural design (!= infra) that plays the biggest leverage in the early days.
The biggest time-sink happens either on finding bugs (going through the call chain) or building features on badly designed code – both products of bad segregation and upkeep of the software.”
Why of Software Entropy?
As the company starts to grow and make a profit, the requirement to build a stable product pops up.
The previous version of the product created needs to be improved, and codes have to be re-worked.
As customers begin to appear, quality soon becomes a priority. To improve this quality, an employee with more experience and a better understanding of the market is added to the team.
Senior developers who come at a greater cost are hired to work on the existing product.
These developers spend most of their time improving old lines of code while also quickly developing new, top-quality features.
Fixing old lines of code to developing new features, most of the developers struggle in getting the desired result.
But as the month’s pass, and with all the efforts of the teams to improve a product, the quality refuses to improve.
This factor is termed software entropy.
What is software entropy?
Based on Wikipedia’s definition, with respect to the second law of thermodynamics in a closed system (where no input or output is made), the disorder cannot be reduced over a period of time.
This law seems to be relevant even in the case of software systems; as a system is modified over a period of time, its disorder only tends to increase rather than decrease with all the effort.
Once new developers try to improve the existing piece of code to improve quality, the product quality gets farther away from desired results.
While the modifications are made to correct the existing lines of code, the “entropy” keeps on increasing, leading to more complex code which is difficult to fix.
This often leads to frustration among the developers and software engineers.
Most of the time, growing startups take the hard route of writing codes from scratch to fix this entropy.
“Software entropy is contagious and if not controlled, becomes an epidemic.”
Then, how can we fix the problem and what would be the best measures to hire a developer who can produce quality work in less time and budget?
So, should startups focus on cost, speed, or quality?
There are exceptions where systems operate critical or life-death operations.
During these early stages, startups are still figuring out their product-market fit. In a noisy and highly competitive SaaS-based world, product-market fit makes or breaks a startup. In addition, the team dynamics and leadership of the team are also at a rapidly developing stage. The lean startup fail-fast-cheaply is a sound philosophy for that reason. Consider it the first entropy challenge.
As the product-market becomes solidified, a startup either plans quality rebuilds on parts or the entire platform completely. At this point moving forward, quality efforts that translate to better customer experiences impact growth. Good growth provides greater funding and customer retention.
Personally, I favor product-led startups and startup founders. Usually, the solutions and vision are robust and their approach incorporates resiliency… and their exits and multiples are far greater (3 to 5 times more than other typical startups). For these types of startup/founders, they are very likely to respect entropy, however, even their understanding of the earlier stages is about speed and fit to gain critical initial momentum.”
How can startups reduce software entropy?
Start with minimal technology
UrbanClap CTO talks about using minimal and reusable technology as “the inability to properly segregate concerns which leads to bad and bloated team designs and over-inflated infra costs.
To solve it well, the biggest and foremost leverage is to ace the culture of intentional architectural design.
– strong design-review culture focusing on modularity and intentional-design for reuse (read here will give you more perspective.)
– frameworks over guidelines – with small teams, evangelizing best practices is a slow process. It’s better to “automate” best practices by engineers building frameworks and tools to standardize different pieces of engineering.”
Most startups start with a certain idea, and it evolves over a period, adding new ideas, features and sometimes it turns into a completely new product.
Ensure that technology A you use during your initial days of the foundation is compatible with technology B which can merge with technology C which you might use in the future.
As the vision of a company evolves, so does the product, and various technologies are introduced (or disrupted) during this journey.
Make sure you use minimal technology until your product is stable and ready to use.
2. Optimize your code
Consider code optimization.
Write and rewrite an integral part of the code and make it a habit to do it as you go forward. This helps you keep a track of all the code which goes live at the backend of a glossy product.
Writing an integral part of the code helps a new employee revise important parts before sending in a new commit.
Integral parts help to differentiate the good part of the code from the bad one.
3. Recheck the commits
Ever committed a code? If not, put it on your bucket list.
It’s a measure of the effort and the commitment developers put into an organization.
The first committed code is celebrated in most startups.
Its time is to recheck these commits. Not the first, not the last, but all.
Make it mandatory for peers to go through all the code commits to ensure no stone is left unturned in getting the best quality code out.
4. Don’t forget assessment tools while hiring
Over a period of time, you will realize that you cannot justify the poor quality of codes to your clients, blaming it on time and cost.
Using technology assessment software from your first hire ensures that you deal with employees who understand your requirement and are capable of yielding results under pressure.
Every wrong hire in a startup costs close to $18,000, from salary and perks to all the processes involved in hiring — most importantly, the interview and assessment hours spend by a small team, working on important projects.
Technology assessment software comes with features such as multiple programming languages, automated test creation, and detailed candidate reports.
Extensive plagiarism features help teams remain free from the usual hassle of ‘keeping an eye’.
Tasks like ‘Java Project’ (part of an existing project that’s shared as an assignment) could be shared with candidates who work in a real coding environment committing actual codes, which gives the right picture of the work that has to be done.
5. Do your homework
Last but not least, do your homework. Follow influencers, read books, connect with people in a similar field.
There are a lot of people who have worked hard to improve software entropy in their organization.
Anand Thaker says, “Knowledge and communication are critical to improving on entropy. We’ve experienced entropy when there is a departure of a team member who had deep knowledge in a part of the system.
Another is when certain parts of the software remain untouched for several months or years. Ensure regular revisits of those capabilities and the underlying code/logic.
Also, consider setting a tone/culture on the philosophy of development. Entropy will always exist, however curtailing its growth so is an art.
As technical or executive leads, you may already know this, but software development is a disciplined process.
Good team members take pride in their work. Recognition of that effort from their peers goes a long way.”
Talk and discuss the learnings people have learned over time.
During their initial phase, should startups focus on quality?
Bad code quality has been a major reason for the failure of many startups. A lot of time, money, and efforts have been lost in improving it over a period of time.
Simple comments like ‘the code is bad’ to ‘improve this line’ are better than doing nothing to improve the code.
Startups are an economic phenomenon breaking new grounds and changing the world.
Raghav Chandra’s suggestions for startups suffering from entropy is “For smaller teams, I have found better leverage in having more teams, and keeping the organization flat, where everyone is hands on.
As Tech Leads / Managers, it is important to groom the team to “think” better. Efforts put in thinking better is what helps, this results in less time fixing things later.
And brainstorming and deep thinking before implementation isn’t a compromise on time or cost – It’s indeed the cheapest way to build for system-level quality.”
It’s time we care about the entropy and hire the best developers who can help reduce it from the products which we build.