A new way
to build AI.
We led UI development for a no-code AI platform: a visual canvas where analysts and domain experts assembled, trained, and deployed working AI systems without writing code.
Making AI buildable by anyone
Our client set out to democratize predictive AI with a no-code platform where anyone — business analysts, domain experts, operations teams — could build, train, and deploy models without writing a single line of code.
That meant the interface could not be a veneer over a scripting environment. The canvas was the authoring surface: whatever a user drew had to become a real, executable AI workflow, validated as they built it and dispatched across cloud infrastructure without them ever seeing a config file.
We led the UI development effort. The system is described in the platform's patent application, US 2022/0206773, which lists our founder among the inventors.
Eight stages. One canvas.
An AI workflow spans eight distinct stages — data ingestion, processing, labeling, training, evaluation, inference, business logic, and deployment. Each carries dozens of configuration options, strict ordering constraints, and incompatible data types at its boundaries.
Worse, those stages do not run in the same place. Labeling might be crowdsourced, training needs GPUs in the cloud, inference runs locally. The interface had to let a non-expert lay all eight out on one surface while the system quietly routed each to the right compute.
And it had to make invalid work impossible rather than merely reporting it later. A user with no ML background cannot debug a pipeline that fails twenty minutes into a training run because a text column was wired into an image model.
Correctness at draw time
Errors had to surface as the user connected two nodes — not after a long, expensive training job had already failed downstream.
Depth without intimidation
Enough control for a data scientist tuning a threshold, approachable enough for an analyst who has never heard of an F1 score.
Distributed execution, hidden
One canvas spanning local CPUs, cloud GPUs, and human labeling — with none of that infrastructure leaking into the interface.
A canvas that compiles
We built a directed-graph editor where each component is a node carrying typed input and output ports, its own configurable parameters, and—where useful—an embedded widget: a column selector, a threshold slider, a form. Users pull components from a palette organized by what they do (data sources, preparation and labeling, visualization, training and evaluation, testing, business logic, deployment) and wire them together.
Connections are type-checked as they are drawn. The moment a user drags from an output port toward an input port, the editor compares the two data types and refuses the connection if they do not match, surfacing the reason inline. An invalid AI pipeline is not something the canvas will let you draw.
The finished graph is not a picture of a workflow — it compiles to an executable workflow specification. The editor emits the components, connections, parameters, and execution contexts as a structured spec, which the orchestrator consumes to allocate resources stage by stage and run the pipeline for real.
Typed ports, validated live
Every node declares typed input and output ports. The editor checks compatibility mid-drag and rejects mismatched connections before they land, so the graph on screen is always a runnable one.
Context-aware graph
Nodes group into the eight execution contexts. The editor detects context boundaries from the connections themselves and marks the handoff points where results pass between environments — local, cloud, or crowdsourced.
Model choice made visual
Users pick a model or let the platform choose. Auto mode evaluates every candidate matching their data type and lays the results out side by side — D3-rendered ROC curves, F1 scores, accuracy — with a slider to set the threshold that decides the winner.
From canvas to deployed AI
Production AI, built by non-experts
A user with no machine learning background could take a raw data source through labeling, training, evaluation, and deployment without leaving the canvas or writing a line of code — and the pipeline they drew was the one that ran.
The platform shipped with a canvas that took users from a raw data source to a monitored, deployed model without leaving the browser — assembling in minutes the kind of pipeline that had previously taken a data engineering team weeks.
The canvas is described in the platform's patent application, US 2022/0206773, which lists our founder among the inventors.