Low-code and no-code development platforms are software tools that let professional developers and non-technical business users build applications through visual, drag-and-drop interfaces — low-code with minimal hand-written code, no-code with none at all.
By 2025, 70% of new applications built inside organizations are expected to use low-code or no-code technology, up from less than 25% in 2020, according to Gartner. That forecast, issued in November 2021, has largely held on the evidence since — the tools moved from departmental curiosities to default options on the IT shortlist, and Gartner’s market-size data (below) tracks the same trajectory.
The idea of doing low-code/no-code development to alleviate reliance on overworked IT development and support teams sounds attractive for data-driven marketers and business users who need to react quickly to digital-first customers.
But while the functionality has been talked about in marketing circles for years, is it actually effective at giving marketers autonomy from IT to act in an agile, data-driven fashion? Or is it overhyped for what it can accomplish? The honest answer requires looking at where the category came from, what the adoption data says, and where projects fail.
How low-code and no-code development works
Low-code and no-code development refers to a set of platforms that enable enterprise developers and non-developer employees (business users) to build software in a modular, componentized, drag-and-drop fashion.
Working this way, professional developers build software quickly by assembling components rather than coding everything from scratch. The same tools let non-professional developers — marketers, business analysts, operations staff — build and test their own applications.
Whether standalone or integrated into a broader platform like a customer data platform (CDP), these tools provide a visual interface for connecting components and apps through application programming interfaces (APIs). It is essentially a digital flow chart for assembling pieces without code skills; another name for the approach is point-and-click development.
Where low-code and no-code came from
The ideas are older than the vocabulary. Low-code platforms descend from fourth-generation languages and the rapid application development tools of the 1990s and 2000s, which shared the same principles: model-driven design, automatic code generation, visual programming.
The name is recent. Forrester Research analysts Clay Richardson and John Rymer coined “low-code” in June 2014 to describe a set of platforms they saw customers choosing for speed — declarative tooling, self-service, near-zero cost to start (SiliconANGLE interview with Rymer, May 2016). Gartner began tracking the category as “low-code development technologies” and, through the hyperautomation boom of 2020–2022, folded it into a broader story: business technologists building their own solutions while professional developers stayed scarce and expensive.
That scarcity is still the engine. “The high cost of tech talent and a growing hybrid or borderless workforce will contribute to low-code technology adoption,” said Jason Wong, Distinguished VP Analyst at Gartner, in the firm’s December 2022 market forecast.
What are the benefits of low-code and no-code development?
The intent of these systems is to liberate marketing and the broader business from relying on enterprise IT to launch products, deploy campaigns, and provide ongoing support. The reality is that consumers move too fast, in too many places, for traditional IT development cycles to keep up.
Deployed properly, low-code and no-code tools reduce time-to-market by compressing development, testing, and delivery. Business users move smaller efforts forward without IT tickets, which frees enterprise developers to work on products with real business value instead of minor production and support duties. Marketers — among the teams most dependent on IT for timely campaign execution — can run more of that work themselves.
In the end, it is about letting employees act directly: clearing IT backlogs and shortening project timelines by moving the simplest builds to the people closest to the problem.
What are the challenges of low-code and no-code development?
The first challenge is visibility. Easy-to-use tools spread across an organization produce work that IT cannot see — the pattern long called skunk works, now usually shadow IT: software outside the ownership or control of the IT organization. The second is scale and cost. Applications built for one team still need maintenance, storage, and cloud budget, and the bill grows with every build. Low-code/no-code fits use cases that do not demand complex programming or deep infrastructure customization; pushed past that boundary, projects stall.
The third is misdirected effort. Without governance and oversight of app creation, teams burn cycles on test-and-fail projects that never produce measurable results. Section for section, the governance model below is the difference between a program and a sprawl problem.
How big is the low-code/no-code market?
The adoption numbers come almost entirely from Gartner, which tracks the category as low-code development technologies. The headline figures, with their dates:
| Indicator | Figure | Source, date |
|---|---|---|
| Low-code development technologies market, 2023 | $26.9B, up 19.6% from 2022 | Gartner, December 2022 |
| New applications using low-code/no-code by 2025 | 70%, vs. less than 25% in 2020 | Gartner, November 2021 |
| Share of low-code tool users outside formal IT by 2026 | At least 80%, up from 60% in 2021 | Gartner, December 2022 |
| Fastest-growing segment, 2023 | Citizen automation development platforms (CADP), +30.2% | Gartner, December 2022 |
| CIOs who have deployed or plan to deploy low-code within 24 months | 64% | Gartner CIO survey, October 2023 |
Two details in that table matter more than the totals. First, the fastest growth sits in citizen automation — workflow builders, forms, connectors between SaaS applications — not in the app-platform segment the vendor marketing emphasizes. Second, the user base is shifting outside formal IT: Gartner’s prediction of at least 80% non-IT users by 2026 is the quantitative version of the citizen-developer trend, and it is the reason governance (below) stopped being optional.
What are low-code/no-code use cases?
Robotic process automation (RPA) is one of the most popular: rule sets for simple decision-making, automating multi-system workflows and administrative processes. Other established use cases include business process management tools and AI-powered virtual assistants or chatbots, small-business transactional systems, HR and field service management, reservation booking, and quote creation.
The top areas for low-code adoption are business process and workflow applications, web and mobile front ends, and customer-facing applications, according to Forrester, which expects the approach to expand into broader reengineering of technology stacks.
Companies also use low-code/no-code for visual analytics, with some systems delivering insights through text or voice-based chat experiences.
Choosing between low-code, no-code, and traditional code
The right choice is a per-project decision, not an enterprise-wide policy. A team that routes every request to engineering spends its most expensive capacity on forms and dashboards; a team that builds everything no-code eventually hits a wall when an application needs logic the visual builder cannot express. Classify each project before anyone opens a builder.
| Question to ask | No-code fits when… | Low-code fits when… | Traditional code fits when… |
|---|---|---|---|
| Who builds and maintains it? | A business user owns it end to end | A developer or technical analyst owns it | An engineering team owns it on a roadmap |
| How complex is the logic? | Simple rules: forms, approvals, filters | Conditional workflows with some custom expressions | Custom algorithms and heavy data processing |
| How does it connect? | Prebuilt connectors cover every system involved | A few systems need API work a developer can write | Deep, bidirectional integration with core systems |
| What if it outgrows the tool? | The process is disposable, so a rebuild is cheap | Logic can be exported or rewritten without starting over | The system must survive platform and vendor changes |
The failure mode is misclassification in either direction. A no-code project that turns out to need custom logic stalls halfway and gets rebuilt in code anyway, so the organization pays for the same application twice; a traditionally engineered project built for what was really a dashboard consumes engineering weeks that simpler work needed. When in doubt, start no-code and define in advance the conditions that would trigger a move to low-code. Running each build as a short, iterative cycle, the way teams work in agile development, makes that handoff far cheaper than a single large build would.
Governance: keeping citizen development from becoming shadow IT
A low-code/no-code program needs a governance model before it needs more builders, because the same ease of use that clears the IT backlog also lets unreviewed applications multiply. Three mechanisms do most of the work:
- An app inventory with named owners. Every application gets a register entry and a person responsible for it. The failure mode without one is the orphaned app: its builder moves to another role, nobody dares modify what they do not understand, and an outdated process keeps running for years.
- Role-based permissions and a sandbox-to-production path. Builders experiment in a sandbox, and anything that reads or writes customer data or core systems passes a logged review before it goes live — the objective being that no unreviewed app becomes an unmonitored path for customer data to leave. This is the same control model a CDP applies, and it only holds if the platform-administrator roles themselves are governed; admin sprawl inside the builder is its own failure mode.
- A retirement rule. Applications that have not been opened or updated in a set period get reviewed for deletion. Without it, the platform bill grows every year while the share of apps anyone actually uses shrinks.
AI agents raise the stakes. Agentic AI can now assemble workflows, segments, and integrations on its own, so the volume of machine-built automation can outgrow any manually maintained inventory. Governance written for human builders needs to cover what agents build, too — an agent-generated workflow needs an owner and a review just as a person-built one does.
Where low-code/no-code breaks: integration, scale, and lock-in
Three failure modes account for most abandoned low-code/no-code projects, and all three are cheaper to check for before adoption than after.
Integration gaps. A platform connector library rarely covers every system a company runs. The fix is unglamorous: list every system the application must read from or write to, and confirm a supported connector or an API path exists for each before committing. An app that cannot reach the system where the data actually lives becomes a manual-export workaround — the exact ticket queue the platform was meant to remove.
Scale ceilings. Visual builders are tuned for departmental workloads, not enterprise transaction volumes. Define expected record counts, concurrent users, and run frequencies up front, and ask what happens at ten times those numbers. The failure mode is an application that works in a pilot and times out in production, forcing an emergency rebuild during the busiest period of the year.
Lock-in. Logic built in a proprietary visual format is hard to move — and the logic is only half the problem, because the proprietary state stores and data models built inside the platform (custom field schemas, identity keys, segment definitions) rarely export at all. Prefer platforms that expose their logic as exportable, documented artifacts, and keep a written description of what each critical application does, so a rewrite starts from a specification rather than from archaeology. The same principle applies to the data itself: customer data belongs in a governed system of record, not trapped inside an application built on a whiteboard.
How is AI changing low-code and no-code development?
The boundary between “developer” and “builder” is blurring from both directions. AI code assistants now write production code from natural-language prompts, and Gartner predicts that by 2028, 90% of enterprise software engineers will use them — up from less than 14% in early 2024 — with the developer role shifting “from implementation to orchestration” (Gartner, July 2025). Meanwhile, low-code platforms absorbed the same models: prompt-to-app builders, natural-language formulas, AI-suggested workflow logic.
The practical consequence for the 2026 buyer: the question is no longer “can you code?” but “can you specify and review?” The engineer statistic is the professional side; the citizen side is already sized — at least 80% of low-code users outside formal IT by 2026, per the table above — and either population generating whole workflows on prompt rebuilds the shadow-IT problem at machine speed. A prompt-generated application still needs a stated requirement, a test, and an owner. Teams that route AI-built workflow automation through the same inventory-and-review gates as human builds get the speed without the sprawl.
For the distinction that matters operationally: AI assistants accelerate professional developers working in code, while agentic platforms assemble entire workflows autonomously. Low-code sits between them, and each year the middle of that spectrum does more of what only engineers could do before.
Low-code/no-code in marketing operations
Marketing teams live inside the pattern this article describes. The everyday builds are no-code: landing pages and forms, approval workflows, lead-routing rules, campaign dashboards. The layer below — marketing automation execution, audience segments, journey logic — started no-code and has been absorbing low-code extension points for years, precisely because marketers cannot wait weeks for a ticket.
The boundary that matters is data. A segment built in a visual interface is only as good as the data behind it; the moment a campaign depends on customer history, consent state, or identity resolution, the right move is to rely on a governed system of record rather than a spreadsheet uploaded to a form builder. The split, practically: route to no-code the landing pages, form logic, lead-routing changes, and dashboard tweaks; keep with IT or engineering anything that touches identity resolution, consent state, or writes customer data — that is CDP work wearing a campaign costume. Marketing ops teams that get this right treat no-code builders as the last mile, not the warehouse.
Does low-code/no-code live up to the hype?
Like most technologies, low-code/no-code is effective in specific situations and disappointing outside them. It will not end the dominance of IT over marketing architecture. It is a step toward modular, componentized development that serves professional developers and citizen builders alike.
Low-code/no-code still requires IT involvement — especially when applications interconnect with mission-critical systems. The cost savings, time-to-market gains, and error reduction are real within their range, and IT will still scale, maintain, integrate, and govern what gets built.
The market keeps expanding regardless. Expect low-code/no-code to keep taking the simple builds, and expect IT departments to keep practicing traditional development where extensive functionality, data governance, and specific deployment environments demand it.
FAQ
What is a citizen developer?
A citizen developer is a business employee who builds applications or automations with low-code or no-code tools instead of waiting for the engineering team. Marketers building segments, analysts assembling dashboards, and operations staff automating approvals all fit the role. The practice speeds delivery, but it works only when every app has a named owner and IT can see what has been built — otherwise citizen development turns into shadow IT.
Is low-code/no-code secure?
Low-code/no-code is as secure as the governance around it. The visual builder itself introduces little risk; the danger is an unreviewed app that touches customer data, connects to core systems, or outlives its owner. Treat every build like production software: grant role-based permissions, keep an inventory of what exists, review anything that handles personal data, and retire apps nobody maintains. Platforms with admin controls and audit logs make this practical.
How much do low-code/no-code platforms cost?
Most platforms price per user per month, with enterprise tiers adding consumption-based and per-application components. Entry tiers are often free or tens of dollars per seat; enterprise low-code application platform contracts run far higher and are usually quote-based, so total cost includes admin, governance, and the integration work the connector library cannot cover. Model three-year cost including the apps you will retire, not just the seats you will buy — abandoned builds are a real line item.
What is the difference between LCAP and CADP?
LCAP (low-code application platform) is the broader category; CADP (citizen automation development platform) is the segment built for non-IT builders. In Gartner’s taxonomy, an LCAP minimizes hand-written code for application development, while a CADP targets workflow automation, forms, and connecting SaaS applications — and CADP was the fastest-growing segment of 2023 at 30.2% (Gartner, December 2022). Gartner treats no-code platforms as a subset of LCAP: an LCAP requiring only simple text expressions. Buy against the use case, not the acronym.