Complexity is like software entropy, it's inevitable. Over time all systems naturally tend toward complexity, and manual intervention is required.
But why is software needlessly complex?
One reason might be engineers' tendency to optimize too early—writing code for hypothetical future events that may never occur.
Oddly enough, even with a crystal ball, we sometimes get it wrong. While it is sensible to ensure a user can not submit a physical carrot as a username, what's less certain is designing an API in such a way that we enable a future use case that does not yet exist.
Or perhaps we prepare for a scale we have not yet reached, writing code and benchmarking it and ensuring it is the most optimal solution, while we have no user base or functional UI. Perhaps this time could be better spent elsewhere.
Even once a user base has been established, the code you write to handle ten users is not the same code you write to handle a million. So effort is often wasted in designing a highly scalable architecture to handle a million users that you might never have. And meeting the demands of a million users is much harder and less intimate than meeting the demands of ten. Instead of spending time designing for a potential future, we can talk directly to our ten users and give them exactly what they want, something less doable at our planned million.
it's as harmful to build for the system of the future, as it is to build an insufficient system for the present. The tools you build for 100 million users when you have a hundred users are going to be completely unusable too and you're going to waste time trying to solve problems you don't have yet that you're going to miss out on all the benefits of being able to look at all your users and see who they are and talk to them. -- Why Can't We Make Simple Software? - Peter van Hardenberg
There is an inherent baseline of complexity that you're happy with as an individual and complexity can be brought in by many dimensions. When multiple dimensions of complexity intersect, they amplify each other—making systems far more difficult to manage.
Supporting millions of users doesn't just mean load balancing and sharding, it means you might need new systems and tools to manage those users, add content moderation or build out support tooling.
Instead of chasing complexity for a scale we may never reach, we can focus on building meaningful, high-quality software for a smaller audience. By keeping our user base niche and intentional, we have the opportunity to engage deeply, iterate quickly, and deliver exactly what our users need. Complexity is inevitable, but rather than front-loading it in anticipation of an uncertain future, we can delay it until it's truly necessary—when our growth demands it, not our assumptions.