Digitalisation seems endless. Another application here. Another dashboard. Another workflow. Another AI application. In practice, digital growth is far from boundless. Behind every application are servers, storage, network capacity, cooling, energy, hardware, and management.
This reality is becoming increasingly visible. Not because datacenters are a new concept, but because pressure on datacenters is growing rapidly. Digitalisation, cloud use, and AI are driving demand for computing power and storage. The International Energy Agency estimates that data centres worldwide consumed approximately 415 TWh of electricity in 2024, accounting for around 1.5% of global electricity demand. Under the baseline scenario, this is set to double toward 2030 to approximately 945 TWh.
The pressure is also tangible in the Netherlands. According to CBS, electricity supply to datacenters in the Netherlands grew to 5.09 billion kWh in 2024, accounting for 4.6% of total electricity consumption. At the same time, grid capacity is scarce. Liander describes network congestion in Amsterdam as a “power jam” and states that the main expansions to resolve congestion are expected to be completed around 2035.
For many organisations, Green IT might still sound like something for later. Interesting, but not urgent. Nice for the sustainability report, but not decisive for the IT roadmap. That perception can change quickly. When organisations start competing for space in the data centre, managing IT efficiently will no longer be an idealistic choice. It will become a strategic prerequisite.
That’s precisely why we at LINKIT are watching this with interest. As an R&D team, we believe it’s important to continuously analyse how we, as an organisation, respond to a rapidly changing world. Which developments are temporary? Which becomes structural? And which topics seem niche today but will determine our customers’ room for manoeuvre tomorrow?
Low-code is not a green sticker
Low-code is a way to develop applications faster. Platforms like Mendix and OutSystems use visual development, reusable components, templates, automation, and built-in lifecycle functionality. But low-code is not automatically sustainable. A poorly designed low-code application can be just as unnecessarily heavy, inefficient, or difficult to manage. In fact, because low-code makes building easier, there’s a risk that organisations build even more applications without proper lifecycle management.
So the question is not “Is low-code green?” The better question is: can low-code help prevent unnecessary digital waste? In many cases, the answer is yes. Not because fewer lines of code are written, but because low-code can help organisations modernise faster through rapid iteration, simplify processes, resolve technical debt, and reduce rework.
1. Replacing legacy without reinventing everything
Many large organisations still run on systems that once made sense but now hinder change. Legacy systems are often difficult to maintain, hard to integrate, and dependent on specific knowledge. This creates workarounds: Excel spreadsheets alongside core systems, manual checks, duplicate data entry, isolated databases, and email processes that have essentially become applications. This is not just inefficient; it also makes sustainability harder. A complex IT landscape is more difficult to measure, optimise, and decommission.
Low-code can play a practical role here. Not always by replacing an entire legacy system at once, but by gradually modernising. For example, with new interfaces, process layers, integrations, or applications that take over specific legacy functionality. LINKIT does this by focusing on business automation and IT modernisation: we help organisations digitalise their processes, simplify their IT landscape, and build future-proof solutions.
2. Faster process automation reduces operational waste
The environmental impact of software doesn’t just lie in the application itself. Just as important is what that application changes in the organisation.
A well-designed low-code solution can reduce manual work, prevent errors, replace paper flows, shorten wait times, and eliminate duplicate administration. These aren’t small improvements. In large organisations, slow processes and manual handoffs can represent a huge hidden cost. Think of planning processes still running on spreadsheets. Customer processes dependent on email. Internal requests are manually retyped across multiple departments. Each of these processes requires time, storage, systems, coordination, and corrections.
Low-code excels at this kind of process automation. Not because every process needs an app, but because low-code makes it possible to test more quickly where automation actually adds value. A real-world example: LINKIT developed a digital solution for the Red Cross for volunteer and event planning, replacing spreadsheets and manual coordination. This allows planners to spend 75% less time on coordination. For IT decision-makers, the core point is this: low-code is not just a development tool. It’s a way to redesign processes.
3. Less development time means less rework
Software development costs more than programming time. There are refinement sessions, test environments, bug fixes, handoffs, documentation, maintenance, and significant rework when users are involved too late. The later in the process it becomes clear that something doesn’t meet needs, the more work is wasted. Low-code (and agile working) can limit this waste by bringing business and IT closer together. Visual models make solutions more tangible faster. Stakeholders can provide feedback sooner. Teams can validate earlier whether a process works. And if something doesn’t work, adjustments are often less costly than in traditional custom development.
This doesn’t mean low-code is always better. For complex, highly critical, or deeply technical systems, traditional custom development may still be the best choice. But for many business applications and workflows, low-code can help prevent time wasted on interpretation misunderstandings, handoffs, and rebuilding. Low-code can also improve user service by making it easier to build the right context and interface, saving time on the user side. The sustainability value, then, doesn’t simply lie in “faster delivery.” It lies in fewer detours.
4. Reusable components prevent digital sprawl
Another advantage of low-code is reuse. Instead of building the same functionality repeatedly, teams can work with existing templates, connectors, modules, and components. This is where vibe-coding currently misses the mark. For large organisations, this is relevant. Not just because reuse is faster, but because it enables standardisation. Less variation in solutions often means less maintenance, fewer dependencies, and more control over quality.
But here, too, reuse is only sustainable if the components themselves are well designed. An inefficient component reused everywhere spreads inefficiency. That’s why reusable low-code components need to be not just functional and secure, but also performant, maintainable, and measurable.
Where low-code is actually not sustainable
Low-code can contribute to Green IT, but only under the right conditions. The technology can also backfire. This happens, for example, when organisations build an increasing number of small applications without governance. Or when temporary solutions become permanent. Or when data, logging, and integrations keep growing without anyone owning lifecycle, performance, or cleanup.
Low-code becomes less sustainable when speed matters more than design quality. When platform overhead isn’t accounted for. When cloud resources are over-provisioned. When nobody measures how much an application is used. Or when “sustainable” is primarily used as a claim without solid backing. The environmental impact of low-code/no-code depends on factors like platform efficiency, resource use, cloud hosting, and integration with existing systems. This makes the choice for low-code context-dependent. It’s not a standard answer, but a design choice.
From R&D to measurable impact
Within LINKIT, we view Green IT as a development that becomes increasingly important as digital capacity becomes scarcer. Not as a standalone sustainability topic, but as part of how organisations future-proof their IT landscape. This also calls for a pragmatic approach. First measure, then claim. Our Green IT initiatives deliberately started small, with a focus on insight and strengthening our internal foundation. We began by researching the environmental impact of our infrastructure and are developing tools to better measure and manage it.
For low-code, this means, concretely: leveraging built-in optimisations, including performance from the design stage; critically managing reusable components; limiting data use where possible; and calculating carbon savings rather than assuming them. Because in the coming years, the question won’t just be whether organisations can digitalise quickly. The question will also be whether they digitalise efficiently enough.
The strategic choice for IT decision-makers
Low-code can help decommission legacy systems, automate processes, shorten development time, and enable component reuse. With this, it can contribute to Green IT. But only if organisations deploy low-code with the same discipline they expect from any other enterprise technology: clear architecture, governance, performance requirements, lifecycle management, and measurable impact.
The real opportunity doesn’t lie in less code. The real opportunity lies in less waste. As digital space becomes scarcer, it’s not automatically the organisations that build fastest that win. Then the organisations that build consciously win.
