Operations needs a refund approval screen this quarter. The platform team wants every new application written in TypeScript, reviewed, and deployed through its own pipeline. Someone has to decide whether this tool goes on a low-code platform or into the main codebase.
The useful question is which approach fits the workload. That depends on the timeline, the team, the integrations, and how much of the stack you need to control. The rest of this piece compares the two on those terms.
What each term means now
Low-code means building on a platform that supplies the scaffolding: UI components, data connections, authentication, permissions, and deployment. Retool, Microsoft Power Platform, and Mendix are common examples. The line has moved. Retool's new app builder produces React apps. You write them in its own chat and code views, or with a coding agent such as Claude Code, and deploy them to Retool. The platform then supplies hosting, version history, source control, SSO, audit logs, and permissions on each data connection.
Traditional development means general-purpose languages and frameworks, with your team running every layer: hosting, auth, the deploy pipeline, monitoring. You control everything, and you build and maintain everything.
Both now involve code. The real difference is who supplies and runs the layers around it.
How a technical buyer weighs the two
Delivery
On a platform, auth, CRUD screens, and common integrations come ready. For internal tools and data applications, that means a working screen in weeks rather than a quarter. The people who use it can react sooner.
Code-first takes longer up front and keeps every decision on the critical path in your hands. That matters for systems that need unusual architecture, low-level performance tuning, or protocols no platform supports.
To compare honestly, measure both with the same numbers. The four DORA metrics work on either stack: deployment frequency, lead time for changes, change failure rate, and time to restore service.
Total cost
Build hours are only part of the bill. A three-year model should include:
Platform licenses and per-user fees, or hosting for a code-first stack.
Security and compliance audits.
Monitoring and on-call.
Ongoing changes, upgrades, and training.
Downtime and incident response.
Maintenance runs for years, while the build takes weeks. A tool that is quick to build and expensive to change costs more over three years than one built carefully. Treat vendor-commissioned ROI studies as scenarios, and build the model from your own license costs and team.
Security and compliance
Neither approach removes the work. Treat a low-code app like any other software: code review, security testing, access control, and a record of the components it uses. For regulated work, check that the platform holds SOC 2 or ISO 27001, and that your own operating model matches.
When people outside engineering build apps, IT needs a few controls in place first: an intake and approval step, separate development, test, and production environments, role-based access, and regular reviews. The OWASP Low-Code/No-Code Top 10 is a usable checklist. On Retool, most of these map onto settings the platform already has, such as permission groups, environments, and audit logs.
Portability
Every stack carries some dependency. Platforms have their own runtimes and deploy paths. Code-first stacks depend on a cloud provider, a database engine, and a framework. The habits that keep either one portable are the same:
Keep business rules, calculations, and long workflows in services and databases you own.
Store data in standard databases, not inside the app layer.
Use platform-specific SDKs where they add clear value, not by default.
Write down how you would move a core app elsewhere, and test it early.
If you want more control behind a platform front end, a back end such as Supabase gives you your own Postgres, APIs, and auth. Giving a low-code app a real back end with Supabase walks through it.
Performance
Performance depends on architecture and data access more than on the platform. On a platform, follow its guidance on pagination, query tuning and indexing, payload size, and caching. Code-first gives you room for work that needs it: services that must answer in under 100 ms, event processing at thousands of requests per second, or custom instrumentation. That room costs engineering time to build what a platform includes. Slow tools are an architecture problem covers the patterns.
Integration depth
If the app mostly reads from and writes to existing systems, a platform does well. Prebuilt connectors reach ERPs, CRMs, identity providers, and warehouses, and custom connectors cover the rest. Version and test those connectors like any other code.
If you are building the core system itself, where the customer or order records are kept, or speaking a domain-specific protocol, start code-first. A platform can still sit on top for back-office screens and approval steps.
Which fits which
Timeline: weeks favor a platform. A roadmap measured in quarters suits either.
Changing requirements: screens and workflows that change monthly favor a platform. Novel data models or protocols favor code-first.
Integrations: mostly SaaS APIs with standard auth favor a platform. Many custom services and niche protocols favor code-first.
Compliance: a certified platform where you can enforce the controls above fits most regulated internal tools. Controls designed at the component level call for code-first.
Performance: human-in-the-loop, transactional apps suit a platform. Low-latency or high-throughput services suit code-first.
Team: product owners and analysts with a few engineers suit a platform. A senior full-stack team can run either.
Most companies end up with both: a platform for the internal tools and approval flows, and code-first for the core product and the services it depends on.
Our view
Decide per workload, and choose the simplest option that meets its constraints, because every layer you take on is one you maintain for years. For an internal tool on existing systems, we recommend a platform with the business logic in services you own. The reason is that the platform supplies the auth, audit, and deploy layers you would otherwise build and run. For the core product, we recommend code-first, because there you need control of every layer. The product owner makes the call with the three-year cost model in hand. What it costs to build a production-ready internal tool helps fill that model in.
