Anti-Scale
No-code flips the economics of software development. Rather than requiring us to go wide to cover our fixed costs for pouring a foundation, we are encouraged to go sharp and assemble a product for one.
Previously, we would build a piece of software before being able to serve the market with it. We hoped to sell enough of the software over multiple users and customers to amortize our development cost.
Technological and demographic developments collided over the past two decades to change this paradigm. We moved from machines requiring very specialized, low-level knowledge to benefit from increasingly higher abstraction levels on which we can build.
These higher levels of abstraction shift the center of value creation. A low-level programming effort focuses on enabling a wide variety of customers with a more capital-intensive model of development that requires amortization. But at the upper levels, the focus becomes the customer since we already have the toolset.
A helpful analogy might be around the bricks to build a house. The brick-maker focuses on making excellent, solid bricks and selling them to people building all sorts of buildings. The quality of a good brick is cross-applicable to many circumstances, so their focus is repeatedly making a good brick - and lots of them. This business responds well to capital and breadth.
In contrast, a bricklayer stacks bricks together with mortar to make walls and structures to serve people. The need is driven by the higher-level project and increasingly by the needs of the end customer. You build one house at a time. The skill is very different, and the number of walls or houses they will create will be orders of magnitude smaller than the bricks shipped.
The many excellent software components and tools available - increasingly marketed as "low code" or "no-code" offerings - are the bricks. The companies that make them want their components to be generally usable and assemblable into the tools clients need. They respond to scale.
The use of no-code and low-code components to deliver value to customers is anti-scale. Anti-scale means that the particular needs of a given customer are reliably more critical than the broad, everyday needs of the market.
In his book Antifragile: Things that Gain from Disorder, Nassim Taleb presses the point that living things require a change to survive, whereas delicate constructs require the absence of change. For example, a teacup is fragile. In contrast, a person is anti-fragile. A teacup will decay and perish in a changing environment. If a living thing does not change - such as breathing, sleeping, eating, and the like - the living thing will die. He points out that antifragility is not the same thing as robustness. A "robust" element will survive a wide variety of circumstances. An antifragile one will only survive in change.
Taleb posits a concave relationship between fragility and antifragility. The answer is not in the middle - robustness - but in the extremes. This bimodal distribution of value applies to anti-scale as well.
Scaling systems maximize profit by reducing variable costs while spreading their fixed costs over a broad set of customers. The more customers they have, the better their net margins. The experience curve of a successfully scaling enterprise looks much more like the old Bruce Henderson graphs of declining marginal production costs.
Anti-scaling systems create and capture value by surrounding the needs of a customer with an ability to pay. The change wrought by no-code and low-code is that the costs of covering a customer's needs are going down dramatically, making it profitable to build an "application for one" for an ever-growing set of customers. Previously, creating an "application for one" might work for an enormous corporation or an intensely financial use case like high-frequency trading. But as the task of app building looks more like bricklaying and less like brick-making, more people can have homes - and those homes can be more nearly bespoke.
In the middle is where many businesses find themselves scratching out a living without getting much profit. If one does not focus on a client's particular needs, one pushes more of the "how do I use this" burden onto the customer. At the same time, if one focuses on a customer segment with more features, one loses the ability to hit a grander scale, so amortizing fixed costs will be more challenging. I have seen companies in this space survive by driving down their engineering labor costs, sometimes by being willing as the founder to accept more of the burdens of working in the business with a lower salary. Rule of thumb: when the answer is "cut your costs," you are in a strategically unsatisfactory position. Moving to places with lower costs of living can help in this regard. But this seems like a tough row to hoe.
The critical skills for an anti-scale technologist will be a deep understanding of the customer needs, familiarity with the available tools, and how to integrate them with those systems and assets that most affect the customer. Get your arms around those will allow "no-code" consultants to both unleash massive value for their customers - and capture great wealth for themselves.
Photo by Darius Cotoi on Unsplash