Skip to content
Silka

Workflow automation2026EN

FLOW

Twelve automations, 4,177 executions in thirty days, and a run you can watch travel the canvas node by node — including the one that fails.

Visit the live site
  • SaaS
  • Product UI
  • Builder canvas
  • Design system
FLOW overview with active workflows, executions and time saved
Industry
Workflow automation
Engagement
Ongoing
Team
1 designer · 2 engineers
Platforms
Web application · Builder canvas · Run inspector · Template library

01

Challenge

Automation tools sell the canvas and hide the aftermath. Dragging three nodes into a happy path is the easy demo; the product is judged on the Tuesday a run dies at step 6 of 8 because a payload changed shape overnight, and the interface answers with a red dot.

FLOW had to carry the whole lifecycle instead: build it, validate it, test it against a real payload, publish it as a version, then live with what it costs and what it breaks. That is eight sections plus a builder and a run inspector, and every one of them reads the same execution data — which is exactly where this class of tool starts contradicting itself.

Workspace
12 workflows · 8 published · 2 paused
Volume
4,177 executions in 30 days
Core difficulty
The failure needs as much design as the happy path

02

Solution

The canvas carries the whole vocabulary: 38 node types across six categories — triggers, actions, logic, AI, integrations, utilities — with the category on the node itself, so the shape of an automation is readable before a word of it is.

A run is not a status light. Every execution keeps its timeline, its log and its input and output per step, so a failure opens as a sentence: failed at step 6, Send follow-up, expected “amount” to be a number but received a string — insert a Transform node before this step. The fix is named on the screen where the break appears.

Publishing is a versioned event with validation in front of it. Environments are separate, published workflows can be paused, restored or rolled back, and a test runs against a JSON payload you supply while the canvas animates the execution node by node.

Vocabulary
38 node types, six categories
Diagnosis
Timeline, log and per-step input/output
Publishing
Validated, versioned, reversible

03

Architecture

  1. L0
    Vite + React shellCode-split routes
  2. L1
    Eight sectionsOverview → settings
    Builder canvasReact Flow
  3. L2
    ValidationRuns before publish
    Execution engineWalks the graph
  4. L3
    Service layerShaped like an API client
  5. L4
    Workspace storeWorkflows, runs, comments
    Integration catalogue10 services, mock OAuth
    AI nodesAnalyze · classify · extract
  6. L5
    localStorageLocal-first
Connections (11)
  • Vite + React shell Eight sections
  • Vite + React shell Builder canvas
  • Builder canvas Validation · before publish
  • Builder canvas Execution engine · test run
  • Eight sections Service layer
  • Validation Service layer
  • Execution engine Service layer
  • Execution engine AI nodes
  • Execution engine Integration catalogue
  • Service layer Workspace store
  • Workspace store localStorage · persist
A local-first client. Every surface goes through one service layer shaped like an API client, so the mock store is the only thing a real backend has to replace.

04

UX

The workspace opens on the sentence an operations lead actually wants — 10 active workflows keeping 505h of manual work off your team — with executions, success rate and time saved beside it as trends rather than decoration.

This is a tool people sit inside all day, so depth is keyboard-first: Ctrl K opens the palette from anywhere, N adds a node, R tests the open workflow, F fits the graph. Nothing that matters needs a mouse to reach.

Breakage is surfaced where it gets fixed. Integrations lead with the one that needs attention — Stripe, the API key was rotated on Aug 15 — and Reconnect sits on the card, instead of leaving it to be discovered by the run that dies.

Entry
What is running and what it saved
Keyboard
Ctrl K · N · R · F · Ctrl S
Breakage
Surfaced where it is fixed

05

UI

Instrument surfaces in near-monochrome with a single acid-lime accent that marks the primary action and the live state and nothing else. Every state the product has to report — success, failure, running, paused, cancelled — carries a label, so colour is never the only thing saying it.

The six node categories get hues of their own on the canvas and nowhere else, which is the one place six colours earn their keep. Light and dark are both designed, chart series included.

06

Build

It runs entirely in the browser. Workflows, runs, integrations and comments live in localStorage behind a service layer shaped like an API client, so swapping the mock for a backend is a change of one function rather than of the interface.

The execution engine, the validator and the analytics are real implementations over that data: a test walks the graph, resolves {{lead.email}} variables against the payload, branches at the condition nodes and emits a log with duration and cost per node.

The canvas is React Flow with custom nodes, edges, notes and a minimap; routes are code-split, so the weight of the builder is not paid by someone who only came to read a run.

07

What it does

  • Builder canvas

    38 node types across six categories on one canvas, with snap-to-grid, minimap, notes and autosave.

  • Test before publish

    Runs against a JSON payload while the canvas animates the execution node by node, at three speeds.

  • Validation and versions

    Validation runs before publishing; published workflows are versioned and can be paused, restored or rolled back.

  • Run inspector

    Timeline, full log and input/output per step, with duration and cost carried on the run.

  • Failure diagnosis

    A failed run names the step, the reason and the fix, and links straight to the node that broke.

  • Variables

    Reference any upstream value with {{lead.email}} syntax; the picker shows exactly what exists at that step.

  • Integrations

    Ten services with mock OAuth, per-service actions, and a card that says when credentials expired.

  • Templates and analytics

    20 forkable workflows with usage and setup time, and a spend split across AI, integrations and executions.

08

Integrations & stack

Integrations

  • Slack
  • Telegram
  • Gmail
  • Notion
  • Google Sheets
  • Stripe
  • HubSpot
  • OpenAI
  • Discord
  • Webhooks

Frontend

  • React
  • TypeScript
  • Vite
  • Tailwind CSS

Canvas & charts

  • React Flow
  • Recharts
  • Framer Motion

Product

  • Execution engine
  • Validation
  • Local-first service layer

09

Where it landed

38
Node types

Triggers · actions · logic · AI · integrations · utilities

4,177
Executions in 30 days

97.6% success, 2.81s average

505h
Manual work removed

≈ 63 working days

Local-first
State

localStorage behind an API-shaped service layer

An automation tool that shows its failures as clearly as its successes: every run keeps the log, the payload and the cost that produced it, and the fix is named on the screen where the break appears.

FLOW builder canvas with the lead qualification workflow
The builder canvas
FLOW run inspector showing a failed execution step by step
A failed run, diagnosed
FLOW analytics with executions, success rate and cost
Executions and spend
FLOW on mobile
Mobile

Every build is designed for the phone as its own experience, not as a narrowed desktop layout.

Got a product that should exist by now?Tell us about it.

Describe what has to change in your business. We will work out what that actually takes — including when it takes less than you think.