Low-code vs custom: when Mendix, OutSystems or Power Apps are no longer enough

Low-code platforms deliver speed where it matters: a first working version of an internal application within weeks, a citizen developer setting up a form flow themselves, a POC for a process that has not yet settled. That is, until the moment it starts to chafe: performance drops under user load, your domain model no longer fits the platform's straitjacket, or you read in your licence renewal quote that runtime costs have doubled. This article honestly describes where low-code works, where it breaks, and what route you have towards custom development without throwing everything away.

Mendix Studio Pro OutSystems Service Studio Microsoft Power Apps Power Platform Dataverse Vendor lock-in
Discuss your low-code journey See the ceilings
PLAFOND MAATWERK

When low-code stops scaling: the ceilings of Mendix, OutSystems and Power Apps

Low-code is not a dirty word. For an internal approval flow, a form-driven back-office tool or a proof of concept to validate a process, it is often the fastest route. But every platform has a built-in ceiling, and the more your organisation grows, the sooner you hit it.

The pattern we see among IT leads and CTOs who approach us is familiar: a team started with Microsoft Power Apps for a simple request workflow, or with Mendix Studio Pro for a customer portal, or with OutSystems Service Studio for a mobile app. The first two years: everything runs smoothly. The business is enthusiastic, the platform delivers. Then comes the third year: user numbers double, an external API has to be integrated, the domain model becomes more complex than the platform comfortably supports, and renewing the runtime licence turns out to cost far more than budgeted.

That is not a failure of low-code. That is the design of low-code: speed and accessibility in exchange for abstraction and platform dependencies. The question is not whether low-code is "good or bad", but whether it is still the right choice for your specific use case, and what you do when the answer becomes no.

What low-code does well

Before we describe the ceilings: low-code platforms deserve credit for what they actually solve. Three scenarios in which Mendix, OutSystems or Power Apps are simply the right choice.

⚡

A quick MVP for internal tooling

A department has a recurring process that currently runs in Excel or email: expense claims, holiday requests, asset tracking. A Power App or Mendix app delivers a working version within weeks. The business validates whether the process works at all before you invest in custom development.

👤

Citizen developer empowerment

Power Platform is designed to let people without a development background build a working solution. For forms, simple workflows and dashboards on existing SharePoint or Dataverse data, that is powerful. The IT department is relieved of the small stuff, and citizen developers deliver their own solutions.

🔄

Simple workflows and forms

Form in, validation, pass on to an approver, notification to the requester, save to a database. A low-code platform is literally built for that type of process. The abstraction that becomes a blocker elsewhere speeds up the work here: no authentication layer to build, no form rendering to design.

The common denominator in these three scenarios: the problem fits within the platform's standard building blocks, the number of users stays manageable, and the complexity of the business logic is low to moderate. As soon as one of those assumptions breaks, you are heading towards one of the ceilings below.

Six ceilings that low-code runs into

Not one limit but several. In practice, organisations rarely hit a single ceiling – they usually stack. You can still mitigate one of the problems described below, two at once becomes painful, and three becomes unsustainable.

1. Vendor lock-in

A Mendix application runs on the Mendix Runtime, a Power App lives inside the Power Platform environment, and OutSystems applications are tied to the OutSystems Platform Server. The code you build is not an open standard that you can migrate to another environment – it is a platform-specific representation. In practice, migrating away means redesigning, not exporting. That is not malicious design; it is how these platforms make their money: by owning the context you work in.

2. Performance at volume

Under normal load, a Mendix or OutSystems application works fine. Under peak load – thousands of concurrent sessions, bulk imports, complex queries on large datasets – the abstraction layer becomes a constraint. At that point you cannot simply hand-optimise your SQL query, you have no direct control over caching strategies, and horizontal scaling is limited to what the platform supports. For an operational back office with a hundred users, that makes no difference. For a customer-facing application with thousands of concurrent visitors, it becomes a wall.

3. Limited domain model

Low-code platforms work with a fixed approach to entity modelling. Mendix has its domain model, OutSystems its entities, and Power Apps uses Dataverse. For CRUD applications, that fits. But when your business logic becomes complex – think event sourcing, polymorphic entities, multi-tenant sharding, or a model with deep inheritance – you have to squeeze your domain into the platform's straitjacket. It can be done, but it turns into an endless dance of workarounds.

4. Integration complexity

Calling an API via a low-code connector works for REST endpoints with standard JSON. But as soon as you deal with SOAP, XML with namespaces, OAuth flows with custom claims, websockets, gRPC or streaming data, you have to write connector code that the platform does not handle for you. At that point you pay the price of low-code (the abstraction layer) without the benefit (speed). With custom development you have direct access to mature client libraries – with low-code you build a wrapper around a wrapper.

5. Licence cost spike

Runtime licences, per-app licences, premium connector licences, AI Builder credits – the licensing structure of low-code platforms is complex and linearly tied to usage. For an initial team of ten users, it is manageable. For a rollout across the whole organisation, you run into a cost curve that climbs steeply. With custom development, the cost is concentrated up front (development); with low-code, it is at the back end (annual licences that scale with your success). Work out in advance what it costs if the solution succeeds – not just what it costs if it stays within one department.

6. Accumulating technical debt

Every workaround you build to get around a platform limitation – a custom Java action in Mendix, a custom connector in Power Apps, an extension in OutSystems – adds technical debt. It is not visible on a dashboard, but you feel it at every platform upgrade and every developer handover. At some point, a large part of your codebase is exactly that: workarounds. At that point you have the worst of both worlds – the licence costs of low-code and the maintenance costs of custom development.

The hybrid route: low-code for admin tooling, custom for the core

The choice is rarely binary. In many organisations, a hybrid architecture is the right middle ground: low-code where it's useful, custom development where it's essential.

In practice, this means your customer-facing application, the platform that delivers the core of your value proposition, runs on a custom stack. That gives you full control over performance, domain model, integrations and extensibility. Your internal admin tooling, the back office where your team checks status, approves an exception or generates a report, can be built perfectly well in Power Apps or Mendix. Speed where the requirements are flexible, robustness where it counts.

Custom for the core

Your customer portal, mobile app, transaction engine, integration layer or platform: anything customer-facing, anything with performance requirements, or anything that sets you apart. This is where custom development beats low-code on every axis that matters: scalability, integration flexibility and total cost of ownership over the medium term.

Low-code for the edges

The approval workflow for purchasing, the onboarding form for new employees, the dashboard where business team leads check their own KPIs. Low-code delivers value here precisely because the business can manage these tools itself: no IT tickets for an extra field, no developer needed for a new view.

The key architectural principle is the dividing line: custom and low-code communicate through a well-defined API layer. Your custom backend is the source of truth, and low-code tooling consumes it via REST or GraphQL. No direct database access, no shared state. That keeps the two worlds modular, so the low-code tools can be replaced or extended without touching the core application.

When custom is the right choice from day one

Not every project suits a low-code starting point. There are three patterns where we generally advise going straight to custom development, not out of ideology, but because the alternatives end up costing more.

🧩

Complex business domain

When your core business revolves around a complex domain model, such as pricing engines with hundreds of rules, multi-leg trade settlement, or regulation-driven workflows with field-level audit trails, it rarely fits the standard entity modelling of a low-code platform. Domain-driven design with explicit aggregates, value objects and domain events requires the expressive power of a real programming language.

🎯

Edge cases that matter

Low-code platforms optimise for the 80% path. That works fine as long as your business shows "normal" behaviour. But if the 20% of edge cases, such as refunds, escalations, error recovery and retry strategies, are critical to your value proposition, low-code quickly becomes a struggle. With custom software, you spell out exactly what happens in every edge condition, with test coverage to prove it.

⚡

Performance-critical scenarios

Sub-100ms latency requirements, bulk processing of millions of records, real-time data streaming, high concurrency on a single endpoint. The abstraction layer of low-code costs you performance here that you can't win back without looking under the bonnet, and you have limited access to what's under there. In these cases, custom development isn't a luxury; it's a prerequisite.

A fair rule of thumb: if your application is where your competitive advantage lies, where you stand out from the market, it's rarely a good place to let a platform vendor dictate your architecture. Custom software gives you the freedom to build and maintain that differentiation.

Migration path: how do you move away from low-code without throwing everything away?

Moving off a low-code platform is not a big bang. It is a phased process in which you run in parallel, shift gradually and eventually phase out the old environment. Here are the four steps we follow in practice.

Domain extraction

Step one: write out the business logic that lives in workflows, microflows or canvas app forms as explicit domain documentation. This is usually the most painful step, because a lot of the logic turns out to be implicit, buried somewhere in platform-specific configuration. But without this foundation, migrating is guesswork.

API layer between old and new

You build a custom API layer that gradually takes over functions from your low-code application. Both run in parallel. The low-code front end first calls its own logic and, over time, the new API. This is the strangler fig pattern: the old environment shrinks as the new one grows.

Modular replacement

For each business module (for example the request flow first, then the approval flow, then reporting) you build a custom equivalent. You validate it in production with a subset of users before you scale up. No irreversible decisions for the entire platform at once.

Phase-out

Once all business-critical functions have been replaced, you switch off the low-code environment and cancel the licences. If they still add value, you may keep one or two minor admin tools running, but the centre of gravity and the complexity now sit in the custom stack that you own yourself.

What we use for custom development after low-code

The choice of technology depends on the type of application and your existing infrastructure, but we prefer mature, widely supported stacks that plenty of developers can work with. No exotic frameworks, no platform lock-in 2.0. Whatever we choose must still be maintainable in five years' time by a developer you didn't have to find through a specialist recruitment partner.

For the backend we work by default with TypeScript on Node.js or C# on .NET, depending on your existing Microsoft investment. For data-intensive services we use Python. Frontend: React with Next.js for customer portals, Astro for public sites that need SEO rendering. Authentication through a mature provider (Auth0, Azure AD B2C). Hosting on Azure or AWS, almost always containerised.

TypeScript Node.js .NET C# Python React Next.js PostgreSQL Azure AWS Docker Kubernetes REST GraphQL

Why Appfront for the low-code versus custom decision

No platform dogma

We don't sell Mendix hours or Power Platform licences. We only provide advice and development work that makes sense for your situation. That means we sometimes recommend staying with low-code, and sometimes starting the migration to custom software, depending on what the numbers show.

Understanding low-code codebases

We have analysed, documented and migrated Mendix, OutSystems and Power Apps applications. We know where the business logic hides, how to read a microflow, and how to read out a Dataverse model to move it to your own schema.

Full custom delivery

We don't just provide the advice, we also deliver the migration and the new custom stack. One partner throughout the entire process, from inventory to production, avoids the handover pain that otherwise makes these migrations so risky.

Frequently asked questions about low-code versus custom

When is low-code genuinely the right choice, and not just a temporary one?
When the application stays internal, the number of users is limited, the business logic is standard CRUD work and the solution's lifespan is short to medium. A Power App for the expense claim flow of a hundred employees can run perfectly well for decades. A customer-facing platform with growth ambitions is a different story: there, low-code becomes a drag within a few years.
How do I know I'm hitting the ceiling of my low-code platform?
A few signs that tend to appear together in practice: you're writing more and more custom code (Java actions in Mendix, custom connectors in Power Apps, extensions in OutSystems) to work around limitations. The licence renewal quote puts you off. The application slows down under load and performance tuning isn't possible without platform support. Finding new developers is hard because the field is niche. If you recognise several of these, a serious conversation about migration is worthwhile.
Is migrating from Mendix or OutSystems to custom software a big investment?
Yes, that's the honest answer. But the calculation has to be set against the recurring annual licence costs plus the rising maintenance costs of platform workarounds. For organisations with a broad low-code rollout, the break-even point for custom software is often within three to four years, along with an independence that can't be expressed in money. We calculate this explicitly in an initial analysis — no migration without a business case.
Can I keep my Power Apps data when migrating?
Yes. Dataverse data can be exported to SQL or another relational store, and structured lists in SharePoint or Dataverse can be read programmatically. The data is rarely the problem — the business logic hidden in canvas apps and flows is. That's where most of the migration effort goes: carefully reconstructing that logic in a maintainable custom codebase.
What is the difference between citizen developer tooling and professional custom development?
Citizen developer tooling is designed to let people without a development background build working solutions for local problems. That's valuable, but it's a different discipline from professional custom development, where architecture, test coverage, security hardening, scalability and long-term maintainability are all on the table. Both can coexist, as long as you recognise which tool fits where.
How does a project at Appfront start in practice?
With an intake in which we go through your current low-code portfolio: which applications are running, how many users, which licences, which pain points. Then a short technical assessment of one or two critical applications — what's in them, how much custom code, how complex the domain is. Based on that, we give you advice: stay, partially replace, or migrate fully. We only start actual development once you're happy with the direction.
What if I'm just starting out and torn between low-code and custom software?
If you're starting now, an honest assessment based on four questions is enough: how complex is your business logic, how many users do you expect, is the system customer-facing or internal, and how long does the solution need to last. With two or more answers of "complex/large/customer-facing/long", custom software is almost always the right choice. With mixed answers, a hybrid architecture is worth considering. We help you make that assessment with no stake in the outcome.

Low-code platform at its ceiling? Time for an honest analysis.

We work out what phasing out Mendix, OutSystems or Power Apps actually costs — and what it delivers. No obligation and no sales pressure.

Book a sparring session

Edit content