I Built a Turing-Complete Visual Low-Code Platform — And Taught an AI to Use It

Wilson Chan — Tue, 11 Aug 2026 08:23:12 +0000

Three years. One person. A low-code platform where the visual editor is genuinely Turing-complete, runs server-side, and — here's the part that matters most — an AI model has already learned how to operate it to build complete enterprise systems from a single sentence.

Why Turing-complete matters

Most low-code platforms are configurators, not programming environments.

You can drag a form together. Define a table. Set up a simple approval chain. But the moment the business logic exceeds what the product manager anticipated — "when this field changes, recalculate these three values, check the department budget, and if it exceeds the limit, route approval to the manager's manager" — you're done. The platform either doesn't support it, or you're writing JavaScript in a cramped textarea inside a web form, which defeats the entire point.

This is not a missing feature. It's a fundamental ceiling.

If a platform's logic layer is a fixed set of pre-built actions, there will always be requirements it cannot express. The only way to remove that ceiling is to make the logic layer Turing-complete: variables, conditionals, unbounded loops, subroutine composition, and I/O. With these primitives, any computable business logic can be built.

That's what I set out to do. The visual code designer in WZSoft compiles a drag-and-drop node graph into server-side JavaScript — and because the target language is Turing-complete, the visual layer inherits that property. You can build a payroll engine. Inventory optimization. Multi-level dynamic routing. Data sync jobs across database schemas. All through the visual editor, no text code written.

Turing-complete isn't a buzzword here. It's the line between "you'll outgrow this" and "you'll never outgrow this."

Why visual matters

If a visual language is Turing-complete, the obvious question is: why not just write code?

The answer is about how humans reason about logic, not how they type it.

When you look at a text file of business logic, you see tokens. When you look at a node graph, you see flow. A conditional branch looks like a branch. A subroutine call looks like a subgraph. The structure is spatial, not linear — your brain processes it differently, and faster.

There's a second reason, less obvious but more important: consistency at scale.

When a team of 10 developers hand-writes business logic, you get 10 different styles. Someone uses ===, someone uses ==. Someone nests 4 levels deep, someone extracts functions. Over 3 years, the codebase accrues a thousand micro-decisions that no one remembers making.

A visual compiler eliminates this entirely. Every if node generates the same pattern. Every database query goes through the same connection path. The generated code is boring and predictable — which is exactly what you want for business logic that needs to run reliably for years.

And the visual graph is the source of truth. There's no synchronization problem between "the diagram" and "the code" — the graph generates the code, every time.

What makes WZSoft different

There are many low-code platforms. These are the things WZSoft has that I haven't seen elsewhere:

1. One visual editor, full-stack

This is the most important architectural decision I made.

In most "low-code" platforms, you use one tool for forms, another for logic, a third for workflows — and they don't talk to each other. WZSoft uses the same visual editor everywhere:

Where	What it does
Form hooks	`beforeUpd` / `afterUpd` — validate input, recalculate fields, trigger side effects when data changes
Backend logic	Standalone code modules — scheduled tasks, data sync jobs, complex business calculations
Workflow nodes	`startdo` / `enddo` — execute logic when an approval reaches a node or leaves it
Data permissions	`selview` / `selupd` / `seldel` — custom SQL filters that are injected into every query automatically

Same node types. Same drag-and-drop interaction. Same execution engine (Nashorn). Learn the editor once, build everything.

The implications are deeper than convenience. A piece of logic you write for a form's validation can be extracted and reused in a scheduled task. A workflow's approval routing can call the same subroutine that the data permission filter uses. There's no boundary between "frontend logic" and "backend logic" — it's all just logic, running server-side, built with the same tool.

I don't know of another low-code platform that does this.

2. Visual programming runs server-side

Almost every low-code platform focuses on UI composition — drag a form, get a page, wire it to an API. The visual part stops at the frontend. Backend logic, if supported at all, means hand-writing JavaScript in a cramped textarea.

WZSoft's visual code compiles to JavaScript that executes on the server via the Nashorn engine, with direct access to:

The database (all five dialects, with automatic SQL dialect translation)
The message queue (email, SMS, in-app notifications)
HTTP clients (call external APIs)
The full Spring context (any Java library or service)
The current user's session (ID, department, organization, roles)

You're not configuring a form — you're programming the backend, visually.

3. Direct SQL with automatic row-level security

You write queries that join any tables, use any SQL functions, aggregate any data. The platform then automatically injects row-level security filters based on the current user's role and data scope — a department manager sees only their department's rows, without you writing a single WHERE clause.

This combination — raw SQL power with automatic, platform-enforced permission filtering — is rare.

4. Five database dialects, one abstraction

MySQL, Oracle, KingBase, Dameng, SQL Server. The platform handles LIMIT vs TOP vs ROWNUM, AUTO_INCREMENT vs SEQUENCE, concatenation syntax differences, and date function variations. Write logic once, deploy to any supported database.

The AI has already learned how to use it

This is the part I'm most excited about, and it's why I'm writing this now.

Every operation in WZSoft is a REST API. Creating an app. Defining a data table. Adding form components. Configuring workflow nodes. Setting role permissions. Generating PDFs. All of it — standard JSON-over-HTTP endpoints with predictable contracts.

This means the platform is machine-operable by design. And over the past months, I've documented its entire operational knowledge — the API contracts, the permission model, the component catalog, the workflow patterns, the database dialect abstractions — into the persistent memory of an AI model (Claude).

The AI now knows how to build systems with WZSoft. Describe what you need in one sentence:

"Build a IT asset management system with request forms, department-level approval."

And it can do it. End to end:

Create the app structure and page hierarchy
Define the data tables with proper field types
Configure form components (dropdowns, date pickers, validation rules)
Design the approval workflow with routing rules and code hooks
Generate the PDF template with [@variable@] placeholders
Assign role-based permissions at the row and column level

No human touches the admin UI. The AI operates the platform like an expert user who has memorized every API contract and every configuration pattern.

Why this is different from "AI code generation"

AI tools that generate code — React components, Express routes, SQL schemas — produce artifacts that need to be maintained, debugged, and kept in sync. Generated code accumulates technical debt just like hand-written code.

WZSoft takes a fundamentally different approach: the AI doesn't generate code. It configures a platform.

The platform guarantees:

Consistent architecture — every app follows the same patterns, regardless of which AI or human built it
Built-in security — row-level and column-level permissions are platform features, not hand-written auth checks
No drift — the visual editor and the REST API share the same underlying data model; there's nothing to get out of sync
Debuggability — since every action goes through the platform's standard pipelines, you can trace exactly what happened

Token economics

A typical AI coding session spends thousands of tokens re-explaining framework conventions, project structure, and coding standards. Every. Single. Session.

With WZSoft, the AI's knowledge of the platform lives in persistent memory. One sentence describing the system you want, and the AI already knows:

Your database dialect and how to construct queries for it
The API contracts for all 18 controllers
The component catalog with all configuration parameters
The permission model (users → roles → apps → pages → data scopes)
The workflow engine's node types and routing patterns

Orders of magnitude fewer tokens per task. The context you're paying for goes toward understanding what you want, not re-learning how to build it.

What this points toward

I believe we're entering an era where AI doesn't assist coding — it operates software directly. Tools designed for human UI interaction will be rebuilt with machine-addressable interfaces. WZSoft is my bet on that direction: a platform that's equally usable by a human clicking through the admin panel and by an AI calling its REST endpoints.

Try it

GitHub: github.com/szwilsonchan/wzsoft
Stack: Spring Boot 2.6.6, Nashorn JS Engine, Vue 3, Spring Security + JWT + Redis, MyBatis + JdbcTemplate, 5 database dialects
License: Free for personal and learning use; commercial use requires a license

Questions about the Nashorn integration, the visual-to-JS compilation pipeline, or the AI-operable architecture? Drop a comment. I'm happy to write follow-up deep dives on any part of the stack.

Built solo. Three years. One person's bet on a different way to build — and use — software.

DEV Community: Wilson Chan