What we are witnessing right now is not an ordinary technology cycle. We are witnessing a restructuring of software logic itself: away from rigid interfaces, toward executable business processes.

Recently, in a conversation with an entrepreneur in the trades, he said something that stuck with me: "Why does every industry software feel like someone built it in 2012 and has just been bolting on menu items ever since?" A fair question. Because in many cases, that is exactly what happened.

For years, the logic of the industry was clear: you buy a large system, painstakingly customize it, live with compromises, and call it digitalization. If things go well, you have a new approval workflow after nine months. If things go badly, you have expensive software that everyone uses half-heartedly. The Mittelstand knows this game. It has paid for it often enough.

What is changing now is not just the quality of Artificial Intelligence. It is the cost structure of building from scratch. And with that, a strategic question shifts fundamentally: do we really need to keep bending old systems — or is it now more sensible to rebuild the relevant parts?

To be clear: this is not about tearing down every existing software landscape. There is no perfect solution. There are legacy systems that are locked in place for regulatory, financial, or organizational reasons. The paradox is this: precisely because legacy systems are so powerful and deeply entrenched, they become increasingly difficult to make AI-first. The larger the castle, the harder the renovation while the tenants are still living in it.

What we see in our consulting practice is a new dialectic. The thesis of the last ten years was: standard software scales, custom software is too expensive. The antithesis of the present is: with AI, customization is suddenly affordable. The synthesis is more compelling: don't rebuild everything — but rebuild the value-creating bottlenecks where standard software is holding operations back.

Why Old Software Often Feels Like a Renovated Parking Garage

Many entrepreneurs intuitively sense that existing software is hard to move. But it is worth examining the mechanics behind this clearly. Because only then does it become apparent why the AI-first transformation in legacy products is so brutally difficult.

Consider a prominent example: Google. Hardly any company in the world has more AI expertise, more computing power, more data, and more talent density. The Gemini models are impressive. And yet, for most users, Gmail still feels remarkably similar after two decades. A few assistant features here, a bit of text suggestion there — but no radical leap in interaction.

Why? Because existing products are not just made of code. They are made of habits, dependencies, permissions, data models, security checks, support processes, and a thousand silent assumptions that have been cemented into the system over the years. You should not imagine such a software landscape as a LEGO kit, but rather as a parking garage from the 1970s: structurally sound, useful, often at full capacity — but every renovation during ongoing operations is loud, expensive, and risky.

In traditional business applications, every seemingly simple change is an intervention in an ecosystem. A new field in a form suddenly affects permissions, reports, interfaces, exports, archiving, mobile clients, and training materials. When AI is then supposed to go "basically everywhere," what emerges is not an elegant leap of innovation, but a patchwork of assistant features. Understandable. But not a quantum leap.

For the Mittelstand, this matters because many industry systems follow exactly this pattern. They were designed in an era when the user was always a human in front of a form. So they built screens, menus, mandatory fields, dropdowns. The machine waited. The human clicked. The entire design of these systems comes from a world before agentic workflows.

Now AI arrives and is supposed to fit into this world. The result often resembles a GPS device strapped onto a horse: technically interesting, but structurally beside the point. We get sidebars with chat windows, automatic text suggestions, occasionally smart search. Nice. But the core process stays the same: the human moves from field to field, translating their intent into the language of the software.

The problem is not that the vendors are incompetent. The problem is the architecture. AI-first does not mean docking a language model somewhere. AI-first means designing the software so that goals, roles, actions, and data are orchestratable in a machine-readable way. That is the difference between a fax machine with Wi-Fi and a genuine digital process chain.

Sounds harsh? It is. But this sobriety is important for entrepreneurs. Because the strategic mistake often lies in underestimating the effort of transforming old systems. People believe a vendor just needs to "add AI." In reality, they are frequently asking that a building with old load-bearing walls suddenly become an open loft — without letting the tenants move out.

The good news: this is precisely where a historic window is opening right now. Not because standard software is disappearing. But because the cost of building an industry-specific sweet spot from scratch is dropping dramatically.

When Software Becomes a Switchboard — and It Suddenly Does Not Matter Who Plugs in the Cables

The most helpful metaphor for modern industry software is, of all things, an old one: the telephone switchboard. Before us stands a large panel with plugs and sockets. Each connection has a defined function. Create customer. Update address. Trigger order. Reorder materials. Start assignment. Generate invoice. Grant approval.

At its core, good enterprise software is exactly that: a cleanly built field of functions, roles, and data relationships. For a long time, it was implicitly clear who operated these plugs: humans. Clerks, dispatchers, project managers, accounting staff. All interface design was oriented toward human operation.

Now that fundamental premise is shifting. If the switchboard exists and a machine-readable description also exists of what each plug does, under what conditions it may be used, and what data it expects, then the question of who operates it loses its exclusivity. A human can trigger the process. Or an AI agent. Or a hybrid human-in-the-loop setup.

This is where APIs, structured permissions, and above all MCP come into play. The Model Context Protocol in this context is less a fashionable acronym than a translation layer. It describes in machine-readable form which tools exist, how they are used, and in what context they operate. Not magic. Infrastructure. But precisely this infrastructure is the difference between "chatbot with nice answers" and "system that actually works."

Imagine a locksmith service. Today, much still runs through phone calls, WhatsApp, Excel, maybe an isolated invoicing solution. A modern agent-ready core could instead map the following: accept job, classify urgency, dispatch nearest technician, send estimated arrival time to customer, check material requirements, prepare invoice, initiate payment collection. The same process can be operated by a dispatcher — or triggered via voice input, messenger, call center, and agent logic.

Or consider construction. A foreman speaks into his phone in the morning: "Log hours for Peter, Tuesday through Thursday, Muellerstrasse project. Order 100 kilos of cement. Sign me out for lunch break at noon." For many, this still sounds like a future scenario. It is not. If the underlying functions are structured and available, a system can process exactly this today: time tracking, material orders, project assignments, status updates. Not as a demo. Operationally.

The decisive point is philosophically almost more banal than it sounds. Wittgenstein wrote, in essence, that the meaning of a word lies in its use. For software, something similar holds true: the meaning of a function lies in its executability within a process. A button is not important because it looks nice. It is important because it triggers an action in the value chain. Once that action is cleanly formalized, the interface becomes secondary.

That is the real revolution. Not the chat itself. But the fact that speech, text, API calls, or agents can all operate the same underlying business function. The interface becomes interchangeable. The process foundation becomes strategic.

This also shifts the key question in software projects. In the past, we asked: what screens do your employees need? Today, we increasingly ask: what operations must your company be able to execute reliably, securely, and in a machine-readable manner? That sounds more abstract, but it leads to better results. Because it builds not around screens, but around value creation.

This is precisely why modern industry software is no longer a UI project. It is an orchestration project. And in this orchestration mindset lies the lever for the Mittelstand.

Why a Small Team Can Now Build What Used to Require a Million-Dollar Budget

Just a few years ago, custom software was an economic minefield for many SMEs. Even simple business applications could devour six-figure sums before the first productive feature even went live. Large ERP projects quickly headed into seven-figure territory. It was not uncommon to pay permanently high licensing and consulting fees because every customization had to go through the vendor or partner channel. Vendor lock-in as a business model.

Security Is Not a Roadblock — It Is the Structural Engineering of the New Build

This much enthusiasm is justified. But it is only one side of the dialectic. The other side is risk. And this risk is frequently either dramatized or trivialized. Neither helps entrepreneurs.

When we build systems that log hours, trigger orders, process customer data, dispatch personnel, and send documents, we are not building toys. We are building operational levers. And every operational lever can cause damage if it is not properly secured. An attack on a system that "can do everything" is not just an IT incident. It can be an attack on your entire value chain.

To be clear: the more agent-ready a system becomes, the more important redundancy, permissions architecture, and traceability become. Anyone who builds a single central instance today that is allowed to execute everything without access levels is not building progress — they are building concentrated risk. That would be like handing the master key to the entire operation to the first available intern — just because they seem friendly.

What does this mean in practice? First: roles and permissions must be granular. An agent that is allowed to reorder materials should not automatically be able to view salaries or delete master data. Second: critical actions need approval logic. Human-in-the-loop is not a sign of technological weakness, but of economic prudence. Third: you need logs and audit trails. When a system acts, we must be able to reconstruct what happened, when, and why.

Fourth: redundancies. If a component fails, operations must continue — in degraded mode if necessary. Fifth: data management and security zones. Not every piece of information belongs in the same bucket. Especially in healthcare, construction projects with confidential documents, or employee-related personal data, segmentation is mandatory, not optional.

The interesting part: here too, AI itself helps with the setup. It can document security rules, simulate tests, check access paths, suggest configurations, and support monitoring. But it does not replace governance. A navigation system can show you routes; you still have to drive responsibly.

On top of this, there is economic turbulence. Until the Jevons paradox fully takes hold — where productivity gains lead to even more usage and ultimately to higher total consumption — many markets will be volatile. Prices come under pressure. Vendors that previously lived off complexity lose margins. Internal roles change faster than org charts. This will not happen quietly.

This is precisely why the Mittelstand needs architectural discipline right now, not tech romanticism. Those who automate blindly create new dependencies. Those who do nothing out of fear preserve old inefficiencies. The synthesis lies in between: bold in building new, sober in governance.

Why Voice as an Interface Is Not a Gimmick, but the Real Productivity Lever

Perhaps the most underestimated change concerns not the backend, but the interaction. Many decision-makers still view voice control as a nice interface. A bit futuristic, a bit convenient. In reality, in many industries it is a massive business lever.

Why? Because in SMEs, the pain point is rarely that people lack information. The pain point is that at the wrong moment they do not have their hands free, are sitting in the car, standing on a construction site, jumping between customers, or having to document information twice. Every media break eats into margins. Every "I'll enter it later" produces errors, delays, and follow-up inquiries.

When a site manager, installer, or field technician can directly trigger operational actions via voice, it is not just the input time that shrinks. The quality of the entire process chain improves. Hours are logged closer to real time. Material needs reach the system sooner. Status updates become more consistent. Follow-up queries from the back office decline. In concrete terms: less email traffic, less phone ping-pong, faster invoicing, better data quality.

In specific scenarios, we are already seeing 30-40% less coordination effort between field teams and back office when structured voice inputs are cleanly connected to operational systems. For documentation and handoffs, 50-60% faster turnaround times are realistic — provided the underlying workflow is not chaotic. AI does not cure bad processes. It just scales them faster.

The Telegram example is particularly compelling because it lowers the threshold. The user does not need to learn new software logic. They use a communication channel they already know. "Log hours for Peter, Tuesday through Thursday, Muellerstrasse project. Order 100 kilos of cement. Sign me out for break." Behind this seemingly mundane message lies a highly relevant shift: language becomes the process interface.

For industries facing skilled labor shortages, this is especially important. The master electrician in Brandenburg does not want another app with eight tabs and 23 mandatory fields. He wants the administration to disappear. When software manages to adapt to the reality of work rather than the other way around, actual usage increases dramatically. And usage is the currency of every digitalization effort. An unused piece of software is, from an accounting perspective, just an expensive piece of furniture.

Of course, voice control needs boundaries. Not every complex booking should blindly emerge from an unstructured message. You need follow-up questions, confirmations, context checks. But this is precisely where modern LLM and agent systems excel: they can recognize intentions, flag uncertainties, and act autonomously only when the conditions are clear.

The real strength, then, is not "speech instead of clicks." It is the translation of everyday work into system logic. That is a difference. We are not simply replacing the keyboard with a microphone. We are shortening the distance between work and documentation. And that distance is one of the most expensive invisible cost blocks in many SMEs.

Sounds crazy? It is — but only from the perspective of old software habits. From the perspective of value creation, it is simply logical.

Where Building from Scratch Really Wins — and Where Customization Is Still the Smarter Choice

After all of this, one might be tempted to derive a simple rallying cry: out with the old, in with the new. That would be too simplistic. As always, the truth lies in the tension between two poles.

The thesis is: building from scratch beats customization. And in many cases today, that is indeed true — especially where three conditions converge. First: your existing system poorly reflects operational reality. Second: the affected process is business-critical and recurring. Third: there are clear data sources and clearly describable actions. In such constellations, a tailored new build is often faster, cheaper, and more future-proof than another year of customization frustration.

The antithesis is equally important: not every process is suited for building from scratch. If an area is extremely dense with regulation, if special standards are reliably met by established systems, or if a company internally lacks ownership or process maturity, then targeted customization may be the wiser choice. Those who digitize chaos get digital chaos. And that is usually only faster, not better.

The synthesis is therefore: build from scratch where differentiation and friction are high. Standardize where commodity processes are stable and adequately covered. This blended approach is often the sweet spot for the Mittelstand.

An example: financial accounting does not need to be reinvented if DATEV handles the core reliably. But the upstream processes — document capture, approval logic, project allocation, mobile documentation — can very well be built from scratch if that is where the bottleneck sits. In construction, a similar logic applies: payroll may stay in the established system. Job dispatching, material communication, and site documentation get rebuilt.

When the answers are clear, the next step is rarely a 120-page requirements document. It is a focused pilot. 3 to 8 weeks for process analysis, architecture, and a first working core. Then real usage, real measurement, real decisions. Not months of slide production.

Because that is precisely the great mistake of traditional digitalization programs: they treat software like concrete. Plan for a long time, pour expensively, then hope it holds. Modern AI-powered product development works more like scaffolding. Put it up fast, test the load, reinforce strategically, then expand. Not arbitrarily. But adaptively.

For entrepreneurs, this is good news. You no longer have to choose between two extremes — total standardization or a total custom project. You can decide modularly. Build new where your business is unique. Connect where standards suffice. That is not technological romanticism, but sound capital allocation.

The Golden Age Does Not Begin with Tools — It Begins with a Decision

The core tension of this topic is obvious. On one side stand old systems that bring stability, history, and well-established processes. On the other side stand new possibilities: agent-ready workflows, voice interfaces, dramatically faster development, much cheaper tailored solutions. Those who bet only on stability miss leverage. Those who bet only on speed build risk.

The solution is neither technology euphoria nor nostalgia. It is dialectical: we keep what holds, and we rebuild what holds us back. Not on principle. But from an ROI perspective. That is precisely where the entrepreneurial art of the coming years lies.

What is beginning today is more than a new chapter of tools. It is a reorganization of software along value creation. Away from form tyranny. Away from menu labyrinths. Toward systems that translate operational intent directly into executable processes. For the Mittelstand, this is not merely convenient. It is strategic. Because smaller companies can suddenly achieve a level of software precision that used to be available almost exclusively to corporations with million-dollar budgets.

If we read this moment correctly, then industry software is no longer the rigid product you buy once and endure for ten years. It becomes the living operating system of an industry — tailored, connectable, agent-ready. That sounds grand. It is. But it is not science fiction. The first productive examples are already running today.

So what should you do right now?

1. Identify your biggest process pain point. Not the loudest, but the most expensive recurring bottleneck.
2. Describe the workflow in verbs, not screens. What needs to be created, reviewed, ordered, approved, or documented?
3. Honestly evaluate build-from-scratch versus customization. Do not cling to the status quo out of habit, but do not tear everything down either.
4. Define security and approval rules before the pilot. Governance is part of the product, not an afterthought.
5. Start small, but productively. A robust core process beats the grand vision tower that cannot survive daily operations.

This is exactly the point where we work with companies: not on the question of which AI tool is currently trending, but on which architecture will actually hold up in their operations. Which processes should be built from scratch. Which are better integrated. And how all of that becomes a setup that works measurably better in six months than it does today.

The golden age of industry software will not belong to those who talk the loudest about AI. It will belong to those who have the courage to rewire their value creation.