The Flow Ecosystem (flow, go-flow, go-flowAPI, flowUI)
Overview
The Flow Ecosystem is a complete, lightweight, and high-performance data integration, ETL (Extract, Transform, Load), and workflow orchestration platform. Designed as a modern, zero-bloat alternative to legacy tools like SSIS and heavy code-based orchestrators like Apache Airflow, the ecosystem spans four modular projects across Go and .NET 10.
This ecosystem enables developers and data engineers to design, execute, and monitor complex ETL pipelines and workflows with minimal overhead, leveraging the strengths of both Go and .NET 10 for performance, flexibility, and a rich user experience.
High-Level list of Components
Each option and feature is covered in detail in the left navigation pane of this documentation repository. A quick overview of the main components is here.
Available Projects and Components
| Project | Path | Language / Stack | Primary Role |
|---|---|---|---|
flow |
flow/ |
Go (1.26.5) Library |
Core embeddable pipeline AST parser, XSD/semantic validator, thread-isolated state Registry, polyglot script & control-flow Executor, and cross-database streaming ETL engine. |
flow.exe |
go-flow/ |
Go (1.26.5) CLI & Packages |
Standalone single-binary CLI engine (flow.exe / go-flow.exe), cryptographic security package (pkg/flowcrypto), embedded local HTMX builder (builder/), Mermaid diagram generator, XSLT 3.0 processor, and helper tools (crypto_tool, db_importer). |
go-flowAPI |
go-flowAPI/ |
Go (1.26.5) HTTP Server |
Unified REST & Server-Sent Events (SSE) API wrapping flow and go-flow. Provides multi-dialect database artifact CRUD (pipelines, options, configs), synchronous and live-streamed execution, cryptographic endpoints, RBAC authentication (BasicAuth & Windows/AD), OpenAPI/Swagger UI, and full API/pipeline audit telemetry. |
flowUI |
flowUI/ |
.NET 10 / Blazor Server (C#) | Rich web-based visual IDE ("Flow Builder Studio") built with Radzen Blazor. Communicates strictly via go-flowAPI (zero direct DB dependencies) to design pipelines, manage configs/options, sign/encrypt payloads, run & stream jobs, and inspect telemetry logs. |
Standalone Execution with flow
The flow binary is an independent executable, with built-in (optional) UI -builder for local, lightweight web-based pipeline design and monitoring. It can be run locally or deployed in server environments for distributed execution.
- Unified Audit & Observability: It optionally logs to the same tables as the governance API (
go-flowAPI) for unified audit and observability. - Pipeline & Workflow Access: It can optionally access and run the same pipelines and workflows defined in the database tables used by API (
go-flowAPI), and UI (flowUI) or call the API directly. - See: Flow Executable Documentation
Centralized Management and Execution
The flowUI and go-flowAPI rely on a shared database for managing artifacts such as pipelines, workflows, and execution logs. This ensures that all components have a consistent view of the system state and can participate in unified audit and observability.
flowUI and go-flowAPI
The flowUI provides an enterprise-grade visual interface for designing, monitoring, and managing ETL pipelines and workflows. It interacts with the go-flowAPI for governance, authentication, and centralized orchestration. The go-flowAPI exposes RESTful endpoints for CRUD operations on artifacts, execution control, and audit logging, ensuring a unified and secure orchestration environment.
Documentation is managed through this repository
All documentation for the Flow Ecosystem, including usage guides, architecture overviews, and component-specific details, is maintained within this repository. This ensures that users and developers have a single source of truth for understanding and working with the ecosystem.
1. High-Level Architecture & Component Relationships
The four projects form a layered architectureβfrom the embeddable core execution library up to the standalone CLI/runner, the central REST API & governance tier, and the enterprise Blazor Studio UI:
flowchart TD
subgraph Presentation["Presentation & Authoring Tier"]
FUI["<b>FlowUI</b> (.NET 10 / Blazor Server)<br/>Enterprise Visual Studio,<br/> Designer, Runner & Logs"]
HTMX["<b>flow.exe</b> <br/>CLI with (Embedded HTMX)<br/>Local Lightweight Web Builder"]
end
subgraph Service["API & Governance Tier"]
FAPI["<b>goFlowAPI</b> <br/>(Go REST Service)<br/>Artifact CRUD, <br/>SSE Execution, Auth/RBAC,<br/> Crypto & Audit API"]
end
subgraph CLI["CLI & Standalone Tooling Tier"]
GFLOW["<b>flow.exe</b> <br/>(Go CLI & Packages) CLI Runner,<br/> flowcrypto <br/>(AES/PGP/PKCS#7/X.509),<br/> Mermaid & XSLT 3.0"]
end
subgraph Core["Core Execution Engine"]
FLOW["<b>flow (package)</b><br/> (Go Library)<br/>AST Parser,<br/> XSD/Semantic Validator,<br/> Isolated Registry,<br/>Polyglot Executor & Stream ETL"]
end
subgraph Storage["Storage & Target Data Engines"]
META[("<b>Central Metadata & Audit DB</b><br/>flow_pipeline_content, <br/>flow_options_content,<br/>flow_config_content, <br/>pipeline_runs,<br/>pipeline_events,<br/> flow_api_events, <br/>flow_api_users")]
LOCALDB[("<b>Local SQLite</b><br/>flow_builder.db")]
TARGETS[("<b>Target Relational & KV Stores</b><br/>SQL Server, Postgres, MySQL,<br/> Oracle, SQLite,<br/>Redis/Valkey, etcd,<br/> BadgerDB, bbolt")]
end
FUI -->|"HTTP REST / SSE (FlowApiClient)"| FAPI
FAPI -->|"Imports pkg/flowcrypto & CLI parity"| GFLOW
FAPI -->|"Embeds Executor & Registry"| FLOW
GFLOW -->|"Embeds Core Engine"| FLOW
HTMX -.->|"Part of go-flow binary"| GFLOW
HTMX --> LOCALDB
FAPI --> META
GFLOW --> META
FLOW --> TARGETS
2. Implementation and Runtime Options
C2 Systems Diagram: Components & Connections
flowchart TB
user["<b>Person</b><br/><i>[Person]</i><br/><br/>Interacts via web UI or<br/>triggers CLI pipelines."]
scheduler["<b>OS Task Scheduler / Autosys</b><br/><i>[External System]</i><br/><br/>Triggers scheduled API calls<br/>and CLI pipeline runs."]
subgraph flow_ecosystem ["Flow Eco System [System Boundary]"]
direction TB
flow_ui["<b>FlowUI</b><br/><i>[Container: Web App / Optional K8s]</i><br/><br/>Provides the UI for managing<br/>and running flows."]
goflow_api["<b>goFlowAPI</b><br/><i>[Container: API / Optional K8s + Kerberos]</i><br/><br/>Handles core logic, Logging, RBAC,<br/>Pipelines and external integrations."]
config_db[("<b>Configuration DB</b><br/><i>[Container: SQL Server]</i><br/><br/>Stores Pipelines<br/>Logs and RBAC data.")]
flow_cli["<b>flow.exe</b><br/><i>[Container: CLI Executable]</i><br/><br/>Independently executes<br/>pipeline.xml workflows."]
flow_pkg["<b>flow</b><br/><i>[Shared Package / Library]</i><br/><br/>Imported during development of<br/>goFlowAPI and flow.exe."]
end
ext_systems["<b>External Systems & Resources</b><br/><i>[External System]</i><br/><br/>Target DBs, web services,<br/>code execution, and files."]
log_db[("<b>Logging Database</b><br/><i>[External Database]</i><br/><br/>Optionally stores execution<br/>audit trail logs from CLI runs.<br/>May be same as Configuration DB.")]
user -->|"Uses [HTTPS]"| flow_ui
user -->|"Executes w/ pipeline.xml [CLI]"| flow_cli
scheduler -->|"Triggers [HTTPS]"| goflow_api
scheduler -->|"Triggers w/ pipeline.xml [CLI]"| flow_cli
flow_ui -->|"Makes API calls to [HTTPS]"| goflow_api
goflow_api -->|"Reads/writes content & RBAC [SQL]"| config_db
flow_cli -.->|"Optionally calls [HTTPS]"| goflow_api
goflow_api -.->|"Imports [Dev Dependency]"| flow_pkg
flow_cli -.->|"Imports [Dev Dependency]"| flow_pkg
goflow_api -.->|"Optionally connects to"| ext_systems
flow_cli -.->|"Optionally connects to"| ext_systems
flow_cli -.->|"Optionally writes logs to [SQL]"| log_db
classDef person fill:#08427b,stroke:#6b6b6b,color:#ffffff
classDef container fill:#438dd5,stroke:#2e6295,color:#ffffff
classDef package fill:#2b8a3e,stroke:#1b5e20,stroke-dasharray: 4 4,color:#ffffff
classDef external fill:#999999,stroke:#6b6b6b,color:#ffffff
class user person
class flow_ui,goflow_api,config_db,flow_cli container
class flow_pkg package
class scheduler,ext_systems,log_db external
style flow_ecosystem fill:none,stroke:#444444,stroke-dasharray: 5 5
2. Deep Dive by Component
2.1 flow β Core Orchestration & Stream ETL Library
Location: flow/ | Module: github.com/etl-madness/flow
flow is the foundational Go package that defines the declarative XML pipeline language and executes the Abstract Syntax Tree (AST).
- Zero Global State (
registry.go): All variable values (string,int,bool,float,datetime,date) and database connection pools are encapsulated inside a thread-safeRegistryinstance. Multiple pipelines can run concurrently in the same OS process without interference. - Parsing & Multi-Stage Validation (
config.go,validator.go,schema.go): ParseXMLConfigdecodes UTF-8 and UTF-16 XML configurations into<variables>,<databases>,<preflight>, and<flow>AST nodes.ValidateXSDvalidates XML structure against the embeddedxsd/pipeline.xsdschema.ValidateASTperforms semantic validation (ID uniqueness, database handle reference integrity, loop bounds).- Multi-Dialect Relational & Key-Value Support (
etl.go,executor.go): - Relational Engines: Microsoft SQL Server (
sqlserver/mssql), PostgreSQL (postgres), MySQL/MariaDB (mysql), Oracle (oracle), and SQLite (sqlite). Automatically translates parameter placeholders ($1,@p1,:1,?) across dialects. - High-Speed Streaming Bulk Copy (
<sql_bulk>): Uses native TDSmssql.CopyInstreaming when targeting SQL Server (supportingtablock,check_constraints,fire_triggers,keep_nulls), and constructs multi-row parameterizedINSERTstatements with prepared statement reuse and a pre-allocated 1D batch arena for other engines while respecting dialect-specific parameter limits (65,535for PostgreSQL/MySQL,32,767for Oracle,32,766for SQLite,2,100fallback). - Key-Value Engines (
<kv>,<kv_bulk>): Native support forbbolt,badger,redis/valkey, andetcdfor rapid state lookups, caching, and SQL-to-KV bulk streaming. - Control Flow & Task Primitives (
executor.go): - Control Flow:
<preflight>,<flow>,<parallel>(semaphore-throttled viamax_threads, cloned worker registries, dirty-variable tracking, andWORKER_<id>_<var>collision namespacing),<if>/<then>/<else>,<foreach>(SQL-driven row iteration),<while>(bounded condition loops),<group>(optional database transaction wrapping with automatic commit/rollback), and<assert>(with<on_failure>fallback nodes). - Polyglot
<script>Execution:- Embedded Go (
language="go"): Powered by Yaegi with injectedhost/varsandhost/dbbridges. - Embedded Lua (
language="lua"): Powered by Gopher-Lua with a globalvarstable (vars.Get,vars.Set, etc.) and stdout capture. - C# Scripts (
language="csx"/dotnet-script): Inline or file-sourced C# execution with NuGet package support. - OS Shells:
shell,cmd,powershell/pwsh,bash,git-bash,zsh,ksh,csh,tcsh,dash,fish,sh.
- Embedded Go (
- Data & File Nodes:
<http_client>(full TLS, proxy, redirect, cookie jar, and header/status capture),<file_read>,<file_save>,<excel_read>,<excel_write>(viaexcelize),<template>(text/template),<template_html>(html/template),<json_path>(ajson),<yaml_path>(yaml.v3), and<xml_xpath>(xmlquery). - Observability & Event Sinks (
observability.go): Emits structuredExecutionEventandRunResulttelemetry (tracking sequence numbers, durations,rows_read,rows_written,rows_affected, andnode_output) to pluggableEventSinkimplementations.
2.2 go-flow β Standalone CLI Runner, Security Engine & Local Builder
Location: go-flow/ | Module: github.com/etl-madness/go-flow
go-flow wraps the flow library into a production-ready single-binary CLI executable (flow.exe / go-flow.exe) and provides reusable sub-packages consumed by go-flowAPI.
- Hierarchical Configuration & Resource Loading (
main.go,cli_loader.go,resource_loader.go): - Loads pipelines (
-file), environment overrides (-config), and pre-baked CLI option profiles (-options, validated viaxsd/options.xsd) from either local disk or database URIs (sql://.../db:...). - Applies a strict override hierarchy: Base Pipeline XML ->
-optionsXML ->-configXML -> CLI-vars. - Expands nested variables in database connection strings up to 3 levels deep.
- Cryptographic Security & Digital Signatures (
pkg/flowcrypto/): - Encryption (
FLOWENC:v1:): Pure-Go AES-256-GCM authenticated encryption with PBKDF2-HMAC-SHA256 key derivation. Supports key resolution via-key-file,-secure-key, orFLOW_SECURE_KEY. - Multi-Standard Digital Signatures (
FLOWSIGNED:v1:&FLOWSIG:v1:): Pure-Go signature creation and verification across:- OpenSSL / PEM: RSA (PKCS#1v1.5 & PSS), ECDSA (P-256, P-384), and Ed25519 keys and X.509 certificates.
- PKCS#7 / CMS (
.p7s): Detached signatures with X.509 certificate and Root CA chain validation. - OpenPGP / GPG (
.asc,.sig): Armored detached signatures and keyrings viagopenpgp/v2.
- Enforces a strict Verify -> Decrypt -> Parse -> Execute lifecycle.
- Self-Documenting Pipelines (
mermaid.go,xslt_processing.go,autodoc/): - Automatically converts pipeline ASTs into Mermaid.js
flowchart TDdiagrams. - Integrates an XSLT 3.0 processor (
lestrrat-go/helium/xslt3) and built-in stylesheets (autodoc_html.xslt,autodoc_md.xslt,pipeline-to-csv.xslt) for automated HTML/Markdown/CSV documentation generation. - Multi-Format Output (
formating.go): Supportscsv,json,jsonpretty,markdown,text, and livestreamoutput formats. - Embedded HTMX Web Builder (
builder/): Invokingflow -builderstarts a self-contained local web UI backed by SQLite (flow_builder.db) for standalone visual pipeline editing without external servers. - Companion Utilities:
crypto_tool/: Standalone CLI for key generation, file encryption/decryption, and digital signing/verification.db_importer/: Utility for importing/exporting pipelines, options, and configs into database tables.
2.3 go-flowAPI β Unified REST, Execution, Security & Audit API
Location: go-flowAPI/ | Module: github.com/etl-madness/go-flowAPI
go-flowAPI exposes the full capabilities of flow and go-flow as a centralized, multi-tenant HTTP service and acts as the sole backend for flowUI.
- 5 Supported Metadata & Audit Database Dialects (
db.go,store.go,tables.go): - Connects at startup (
-dsn/FLOW_API_DSN) to SQL Server, PostgreSQL, MySQL/MariaDB, SQLite, or Oracle. - Automatically adapts SQL dialect syntax and schema prefixes (
DefaultSchema = "dbo."on SQL Server/Postgres, stripped automatically on SQLite/MySQL/Oracle). - Artifact Management & Upload (
handlers.go,store.go): - Full CRUD, file upload (
POST /api/v1/upload/{type}), and raw XML export across three artifact repositories:pipelines->flow_pipeline_contentoptions->flow_options_contentconfigs->flow_config_content
- Supports addressing artifacts by either unique
Nameor databaseID, with on-the-fly decryption (?decrypt=true). - Synchronous & Live SSE Pipeline Execution (
executor.go): - Full parity with
go-flowCLI flags: supports inline XML ordb:<name>/ artifact ID references,-configand-optionsmerging, runtimevars, XSD/AST validation (/api/v1/validate), preflight-only execution, XSLT transformations, signature verification, and decryption. - Synchronous Execution:
POST /api/v1/executeandPOST /api/v1/execute/{type}/{id}. - Real-Time Server-Sent Events (SSE):
POST /api/v1/execute/streamandPOST|GET /api/v1/execute/stream/{type}/{id}stream livenode_eventupdates as each AST node starts and completes, followed by a finaldoneevent. - Cryptographic REST Endpoints (
handlers_crypto.go): /api/v1/crypto/keygen: Generates AES-256 keys, RSA-2048/4096, ECDSA-P256/P384, Ed25519 keypairs (with optional self-signed X.509 certificates), and OpenPGP keypairs./api/v1/crypto/encrypt&/api/v1/crypto/decrypt: Wraps/unwrapsFLOWENC:v1:payloads./api/v1/crypto/sign&/api/v1/crypto/verify: SupportsOPENSSL,PKCS7, andPGPschemes withnone,sign-then-encrypt, andencrypt-then-signenvelope modes.- Authentication & Role-Based Access Control (
auth.go,win_groups_windows.go): - Database-Backed BasicAuth: Validates users against
flow_api_users(supporting bcrypt hashes,sha256:digests, or constant-time plaintext matching). - Windows / Active Directory Integrated Auth: Supports
DOMAIN\userandDOMAIN\groupresolution viaX-Flow-Windows-User/X-Flow-Windows-Groupsheaders and native Windows group lookup so AD groups can be granted permissions directly inflow_api_users. - Granular Roles:
read-only,execution-only,write/upload, andall(combinable via comma-separated lists). - Comprehensive Telemetry & OpenAPI (
telemetry.go,swagger.go): - Every API request is audited to
flow_api_events(/api/v1/audit). - Every pipeline run logs summaries to
pipeline_runs(/api/v1/runs) and step-level metrics + 64 KB UTF-8 truncated & secret-redactednode_outputtopipeline_events(/api/v1/events). - Built-in interactive Swagger UI at
/swagger/(and/docs) backed by an OpenAPI 3.0.3 spec (/api/v1/openapi.json).
2.4 FlowUI β Enterprise Blazor Visual Studio
Location: flowUI/ | Solution: FlowUI.sln (.NET 10 / Blazor Interactive Server)
flowUI is a modern, stateless web IDE ("Flow Builder Studio") built with ASP.NET Core 10 Razor Components and Radzen Blazor.
[!IMPORTANT] Strict API-Driven Architecture:
flowUIhas no direct database connection and no internal database. All artifact persistence, validation, execution, cryptography, authentication, and log queries flow exclusively throughFlowApiClienttogo-flowAPI.
- Workspace Tabs (
Components/Tabs/): - Pipeline Designer (
PipelineDesignerTab.razor): Visual drag-and-drop/card-based AST builder for Variables, Databases, Preflight steps, and Flow nodes (including nested<parallel>,<if>,<foreach>,<while>,<group>, and<assert>blocks), paired with bidirectional XML generation (XmlGeneratorService.cs), XML import (XmlImporterService.cs), and live Mermaid.js diagram rendering. - Config (
ConfigTab.razor): Visual and XML editor for environment override<Configuration>artifacts (flow_config_content). - Options (
OptionsTab.razor): Editor for reusable<cli_options>execution profiles (flow_options_content). - Runner (
RunnerTab.razor): Interactive execution console supporting artifact selection, runtime variable overrides, validation/preflight toggles, cryptographic key/certificate inputs, and live SSE event streaming fromgo-flowAPI. - Logs (
LogsTab.razor): Unified telemetry explorer forpipeline_runs, step-levelpipeline_events(with detailednode_outputinspection viaEventDetailModal.razor), andflow_api_eventsAPI audit trails. - Settings (
SettingsTab.razor): API connectivity diagnostics, database connection testing (/api/v1/db/test), andflow_api_usersRBAC user management. - Handbook (
Handbook.razor&DocsService.cs): Embedded searchable component reference guide rendered fromFlowUI/Docs/*.mdvia Markdig. - Integrated Cryptographic Studio (
CryptoSignVerifyModal.razor&FlowCryptoService.cs): Interactive UI for generating keys/certificates, encrypting/decrypting artifacts (FLOWENC:v1:), and signing/verifying payloads (FLOWSIGNED:v1:). - Pluggable UI Authentication (
Services/Auth/): FlowApiPassthroughAuthProvider(ApiBasic): Authenticates directly againstgo-flowAPIusing HTTP Basic Auth credentials entered at login.WindowsIntegratedUiAuthProvider(Windows) &WindowsCredentialsUiAuthProvider(WindowsCredentials): Resolves OS/Active Directory identity (DOMAIN\user) and group memberships (DOMAIN\group) via Windowsadvapi32.dllLogonUser/WindowsIdentityand maps permissions againstflow_api_usersingo-flowAPI.
3. Shared Database Schema & Storage Model
Across flow.exe, go-flowAPI, and flowUI, a defined 7 table schedma (defaulting to schema dbo. on SQL Server and PostgreSQL) powers artifact storage, security, and observability:
| Table Name | Used By | Purpose |
|---|---|---|
flow_pipeline_content |
flow.exe, go-flowAPI, flowUI |
Stores named <pipeline> XML definitions (plaintext, FLOWENC:v1: encrypted, or FLOWSIGNED:v1: signed). |
flow_options_content |
flow.exe, go-flowAPI, flowUI |
Stores reusable <cli_options> execution profiles. |
flow_config_content |
flow.exe, go-flowAPI, flowUI |
Stores environment-specific <Configuration> override profiles (variables & database connections). |
pipeline_runs |
flow.exe, go-flow.exe, go-flowAPI, flowUI |
Run-level execution summary (run_id, status, started_at, finished_at, duration_ms, task_count, user_name, hostname, error_class, error_message). |
pipeline_events |
flow.exe, go-flow.exe, go-flowAPI, flowUI |
Granular step-level audit trail (sequence_num, node_kind, node_id, status, rows_read, rows_written, rows_affected, node_output). |
flow_api_events |
go-flowAPI, flowUI |
HTTP API audit trail recording every REST operation, authenticated user, status code, duration, and JSON details. |
flow_api_users |
go-flowAPI, flowUI |
Users, Active Directory groups, password hashes (bcrypt/SHA-256), and role permissions (read-only, execution-only, write, upload, all). |
4. End-to-End Execution & Security Lifecycle
Whether a pipeline is triggered from the CLI (go-flow), via REST/SSE (go-flowAPI), or interactively from Flow Builder Studio (flowUI), the ecosystem executes a deterministic 6-stage pipeline lifecycle:
sequenceDiagram
autonumber
actor User as User / Scheduler
participant UI as flowUI (Blazor Studio)
participant API as go-flowAPI (REST / SSE)
participant Crypto as go-flow/pkg/flowcrypto
participant Engine as flow (Registry & Executor)
participant DB as Metadata & Target DBs
User->>UI: Click "Run Pipeline" (or invoke CLI / API)
UI->>API: POST /api/v1/execute/stream (Basic / Windows Auth)
API->>DB: Authenticate User/Group (flow_api_users) & Log API Event
API->>DB: Load Pipeline, Options & Config XML (flow_*_content)
API->>Crypto: 1. Verify Signature (FLOWSIGNED:v1: / .sig / .p7s / .asc)
API->>Crypto: 2. Decrypt Payload (FLOWENC:v1: AES-256-GCM)
API->>Engine: 3. ParseXMLConfig + Apply Overrides (Options -> Config -> Vars)
API->>Engine: 4. ValidateXSD & ValidateAST
API->>Engine: 5. InitVariables & InitDatabases (3-level conn string expansion)
loop For each AST Node in <preflight> and <flow>
Engine->>DB: Execute SQL / Bulk Stream / KV / Script / HTTP
Engine-->>API: Emit ExecutionEvent (rows read/written, node_output)
API-->>DB: Insert into pipeline_events
API-->>UI: Stream SSE event: node_event
end
Engine-->>API: Return RunResult
API->>DB: Insert summary into pipeline_runs & flow_api_events
API-->>UI: Stream SSE event: done (Final Run Summary)
5. Deployment Topologies
The ecosystem supports flexible deployment models ranging from zero-dependency single-binary CLI execution to full containerized microservices (detailed in go-flowAPI/DOCKER.md and flowUI/DOCKER.md):
- Standalone CLI / Batch Agent (
go-flowonly): - Deploy the single
flow.exe/go-flowbinary on any Windows, Linux, macOS, or FreeBSD host (e.g., via Cron, Autosys JIL, or Windows Task Scheduler) using local XML files orsql://database URIs. - Local Developer Mode (
flow.exe -builder): - Run
flow.exe -builder -builder-port 8080to use the embedded HTMX visual builder backed by a localflow_builder.dbSQLite file. - Headless API Server (
go-FlowAPI+ Database): - Run
go-flowAPIvia binary or Docker Compose (docker-compose.sqlserver.yml,docker-compose.postgres.yml,docker-compose.sqlite.yml) for CI/CD artifact publishing, remote job triggering, and centralized auditing. - Full Enterprise Studio Stack (
FlowUI+go-flowAPI+ Database): - Orchestrated via
flowUI/docker-compose.full.yml(self-contained with SQL Server 2022 and automatic schema initialization),flowUI/docker-compose.api.yml(UI + API containers against an external DB), or Windows Containers (Dockerfile.windows) for native Active Directory / Windows Integrated Authentication.