Low-Code/No-Code Platforms: Why the $65B Market Boom Matters for Engineers
The low-code/no-code market hit $13.8B in 2023 and analysts expect it to balloon to $65B by 2028. Your CEO has definitely seen these numbers. Your product manager already has a Retool login. And somewhere in your organization, a business analyst just deployed a workflow automation that touches your production database.
You should care about this. Not because low-code is going to replace engineers (it won't), but because it's creating a new category of technical debt that traditional tooling can't see.
The Promise vs. The Reality
Low-code platforms sell speed. Build an internal tool in hours instead of weeks. Connect APIs with drag-and-drop. Let "citizen developers" solve their own problems without bothering engineering.
I watched a fintech company reduce their internal tool backlog from 6 months to 3 weeks using Retool. Their ops team built dashboards, admin panels, and data reconciliation tools without writing a single line of backend code. Engineering loved it initially — they got to focus on customer-facing features instead of building the 47th variation of a CRUD interface.
Two years later, they had 180+ low-code applications in production. Nobody knew what half of them did. Three different tools performed similar reconciliation tasks because teams didn't know what existed. When they needed to migrate from Postgres to a distributed database, they discovered that 40+ Retool apps had hardcoded SQL queries that would break.
The engineering team spent 4 months auditing and fixing low-code apps. The "we saved engineering time" narrative evaporated.
The Invisible Architecture Problem
Low-code platforms create what I call "ghost architecture" — production systems that don't show up in your service mesh, don't appear in your dependency graphs, and definitely aren't documented in your wiki.
Traditional code has structure you can analyze. You can grep for API endpoints, trace function calls, build dependency trees. Low-code platforms generate this stuff behind a GUI. The actual runtime artifacts live in proprietary formats. Your static analysis tools see nothing.
Consider OutSystems or Mendix applications. They compile to actual code, but that generated code is effectively write-only. Nobody reviews it. Nobody understands it. When something breaks, you debug through the visual builder, not by reading stack traces.
The worst part? These platforms touch everything. They query your database. They call your APIs. They integrate with third-party services. They have authentication logic. They handle PII. But they exist outside your normal code review process, your security scanning, your architecture review.
You've effectively got a parallel codebase that your engineering tools don't know about.
The Knowledge Fragmentation Crisis
Here's what actually happens when you introduce low-code platforms:
Your engineering team knows the core application. They understand the data models, the business logic, the architecture decisions.
Your business teams know the low-code applications. They know which Zapier workflows connect which systems. They know which AppSheet apps the field team uses. They know which Power Automate flows process invoices.
Nobody knows both. And critically, nobody knows what depends on what.
I talked to a CTO at a Series C company who discovered this the hard way. They needed to deprecate an old API endpoint. Engineering checked all the code repositories — safe to remove. They deprecated it, and 15 internal tools broke immediately. All of them were low-code applications that the business teams had built. Engineering had no idea they existed.
The API endpoint stayed. They're still supporting it three years later because mapping all the dependencies would take longer than just maintaining it.
Why This Matters More Than You Think
The low-code market is growing at 25% annually. That's not slowing down. Every year, more of your production environment gets built outside traditional codebases.
This isn't necessarily bad. Low-code tools genuinely enable faster iteration for certain use cases. The problem is that we're treating them like they're separate from "real" engineering when they're deeply integrated into your production environment.
You need to think about low-code outputs the same way you think about any other code: as technical assets that need maintenance, documentation, and governance. The difference is that your current tools can't see them.
Code complexity metrics? They don't measure visual workflows. Dependency analysis? Doesn't catch low-code integrations. Feature documentation? Doesn't include the 200 Airtable automations running in production. Team knowledge mapping? Has no idea that Sarah in operations is the only person who understands the inventory reconciliation process built in Bubble.
The Code Intelligence Solution
This is where code intelligence platforms like Glue become relevant. The key insight is that low-code platforms ultimately generate behavior — API calls, database queries, feature functionality — and that behavior can be discovered and mapped regardless of how it was created.
Glue's AI agents analyze running systems, not just static code. They discover features by watching what actually happens in production. When a low-code app queries your user table, Glue sees it. When it calls your payment API, Glue maps it. When it implements a feature that overlaps with something in your main codebase, Glue flags the duplication.
The technical debt analysis works on any codebase — including the frankly weird code that low-code platforms generate. Glue can tell you which systems are changing frequently (high churn), which have complex interdependencies, and critically, which people in your organization understand which parts of your hybrid architecture.
What You Should Actually Do
First, acknowledge that low-code isn't going away. Fighting it is pointless. Your business teams will find ways to build what they need. Better to make it visible than to pretend it doesn't exist.
Second, treat low-code applications like first-class citizens in your architecture. They touch production data. They implement business logic. They have users. They deserve the same governance as your "real" code.
Third, solve the visibility problem. You need tooling that can map your entire production environment, not just the parts that live in GitHub. This means going beyond static analysis to runtime discovery.
When you're evaluating changes — migrating databases, deprecating APIs, refactoring core services — you need to know what will break. That includes the Retool dashboards, the Zapier workflows, the Make.com automations, and whatever other low-code tools your teams are using.
Glue helps here by generating always-current documentation from actual system behavior. When your low-code apps change, the documentation updates automatically. When dependencies shift, the maps reflect reality. When you need to know who understands a particular workflow (even if it was built in a no-code platform), Glue's knowledge mapping shows you.
The Competitive Angle Nobody Talks About
Here's the really interesting part: your competitors are dealing with the same problem. They're also accumulating low-code technical debt. They're also struggling with visibility.
The companies that figure out code intelligence for hybrid codebases first will move faster. They'll know what they have, what they can safely change, and what gaps exist in their feature set compared to competitors.
Gap analysis becomes particularly powerful when you can map both traditional code and low-code outputs. You can see not just what your competitors have that you don't, but also spot the redundancies in your own stack — the features you've built three different ways across two codebases and one low-code platform.
The $65B Question
The low-code market is heading toward $65B because it solves real problems. Business teams need tools. Engineering teams are overloaded. The velocity gains are genuine.
But velocity without visibility is just accumulating debt faster.
The question isn't whether to use low-code platforms. They're already in your environment. The question is whether you have the tooling to understand what you've built, maintain it effectively, and evolve it without constant fear of breaking something you didn't know existed.
Traditional code intelligence tools were built for traditional codebases. They assume everything is in version control, written in a programming language, and structured in ways that static analysis can parse.
That world is gone. Modern production environments are hybrid — some traditional code, some low-code outputs, some third-party integrations, some infrastructure-as-code. You need intelligence platforms that can handle all of it.
The $65B market boom is happening whether you're ready or not. Make sure you can see what it's building.