Automated Platform is a full-stack visual workflow automation application. It lets users build workflows by placing nodes on a canvas, connecting them, configuring each node, saving the workflow to PostgreSQL, and running it through a Spring Boot execution engine.
The project is inspired by the core workflow-building experience of tools such as n8n:
- React and React Flow provide the visual workflow editor.
- Spring Boot provides the REST API and workflow execution engine.
- PostgreSQL stores workflows, nodes, connections, executions, and node results.
The project demonstrates how a visual workflow editor can turn a directed graph into a durable, observable execution. It is designed as a focused full-stack system: the frontend is responsible for graph editing and user feedback, while the backend validates, persists, schedules, and executes the workflow.
The editor includes a React Flow canvas, a searchable node library, workflow controls, a node configuration inspector, and input/output panels for execution results.
- Visual construction of connected automation workflows.
- Persistence of workflow metadata, nodes, connections, and execution history.
- Manual and webhook-based workflow triggers.
- Branching with IF nodes and multi-input processing with Merge nodes.
- Data transformation between integrations through structured JSON items.
- External HTTP, Gmail, and Telegram integrations.
- Asynchronous execution with queueing, worker ownership, retries, timeouts, and lease recovery.
- Node-level observability so users can inspect input, configuration, output, and failure details.
- Create and open workflows
- Add, configure, move, and delete nodes
- Connect nodes visually, including IF branches and Merge inputs
- Save a complete workflow graph to the backend
- Run workflows from the editor
- View execution status and node-level results
- Inspect input, configuration, output, and errors
- Use HTTP, Transform, IF, Merge, Delay, Gmail, Telegram, Manual Trigger, and Webhook nodes
The project has been documented from the beginning through recorded development videos. The videos show the project progress, implementation decisions, frontend integration, and workflow demonstrations.
Watch the development recordings on the my YouTube channel.
Automated-Platform/
├── Backend/ # Spring Boot backend
│ ├── src/
│ │ ├── main/java/ # Backend source code
│ │ └── main/resources/
│ │ └── application.properties
│ ├── pom.xml
│ ├── Dockerfile
│ └── .env # Local backend configuration
├── Frontend/ # React/Vite frontend
│ ├── src/
│ │ ├── App.jsx # Workflow editor
│ │ ├── api.js # Backend API client
│ │ ├── nodeDefinitions.js # Frontend/backend node mapping
│ │ └── index.css # Application styling
│ ├── package.json
│ └── .env # Local frontend configuration
├── docs/images/ # Documentation screenshots
│ └── workflow-editor.png
└── README.md
The frontend handles the visual editor and user interaction:
- Add nodes from the Node Library.
- React Flow renders nodes and connections.
- The configuration panel edits the selected node.
- The frontend converts the canvas into a workflow graph.
- The graph is sent to Spring Boot.
- The frontend starts an execution and checks its status.
- The inspector displays input and output for the selected node.
The backend handles persistence and execution:
- Workflow creation and retrieval
- Graph persistence and validation
- Node execution
- Execution status management
- Node-level execution results
- HTTP, Gmail, and Telegram integrations
PostgreSQL is the persistent source of truth. Browser drafts or local state are not a replacement for saving a workflow to the database.
React/Vite frontend
│ REST API
▼
Spring Boot application
│
├── Workflow validation and graph persistence
├── Bounded execution queue
├── Execution worker and lease heartbeat
├── Graph scheduler and node executors
└── Execution and node-result persistence
│
▼
PostgreSQL
The main domain records are workflows, nodes, node connections, executions, and node executions. A workflow stores its graph; an execution stores one run of that graph; node executions store the status, attempts, input context, output, and error information for individual nodes.
- The frontend saves the graph when required and requests a manual or webhook execution.
- The backend validates node limits, connection limits, node types, and graph rules.
- A new execution is stored as
QUEUEDand placed on the in-memory execution queue. - The worker claims the execution, changes it to
RUNNING, and creates a renewable ownership lease. - The engine finds the correct trigger node and schedules ready nodes in graph order.
- Independent ready nodes may run concurrently. Branch connections are marked active or skipped according to the node result.
- Each node result is persisted with its status, attempt count, input items, output items, and error details.
- Transient failures are retried with backoff. A node timeout is treated specially for HTTP requests because the external system may have processed the request even when the response was not received.
- The worker heartbeat renews ownership periodically. If ownership is lost, the engine stops scheduling additional work instead of writing results it no longer owns.
- The frontend polls execution and node-result endpoints and displays the final status in the editor.
The current implementation uses a bounded queue, a two-minute execution lease renewed every thirty seconds, a sixty-second per-attempt node timeout, and up to four retries after the initial attempt. These values are implementation behavior, not user-facing workflow settings.
- Java and Maven
- Node.js and npm
- PostgreSQL
- A Gmail account and app password for Gmail nodes
- A Telegram bot for Telegram nodes
- Network access for external HTTP requests
Never commit real credentials, API keys, bot tokens, email passwords, or database passwords.
The backend loads a .env file through Spring configuration. Use placeholder values locally:
DB_URL=jdbc:postgresql://localhost:5432/automated_platform
DB_USERNAME=your_database_user
DB_PASSWORD=your_database_password
FRONTEND_URL=http://localhost:5173
TELEGRAM_BOT_TOKEN=your_telegram_bot_token
GMAIL_USERNAME=your_gmail_address
GMAIL_APP_PASSWORD=your_gmail_app_passwordCreate the PostgreSQL database before starting the backend. The current backend configuration manages schema updates through Hibernate.
Create Frontend/.env:
VITE_API_BASE_URL=http://localhost:8080Use the actual backend URL if it runs on another host or port. Restart Vite after changing .env.
Open two terminals from the project root.
cd Backend
.\mvnw.cmd spring-boot:runcd Frontend
npm install
npm run devOpen the URL printed by Vite, usually http://localhost:5173.
cd Frontend
npm run build
npm run preview- Start PostgreSQL, the backend, and the frontend.
- Open the frontend.
- Click New workflow if no workflow is open.
- Add a trigger node from the Node Library on the right.
- Add action, logic, transform, or integration nodes.
- Connect nodes by dragging from a source handle to a target handle.
- Click a node on the canvas to open its inspector.
- Configure the node.
- Click Run.
Run saves dirty graph changes before starting execution. A workflow loaded from the database can be run directly when it has no unsaved changes.
Most nodes have one input and one output. Manual Trigger and Webhook normally have only an output. Gmail and Telegram are normally terminal nodes.
IF has two outputs:
true: condition matchedfalse: condition did not match
Merge requires exactly two incoming input streams. Connect both branches to Merge and configure how the two inputs should be combined.
Example:
Manual Trigger → HTTP Request → Transform → Telegram
Starts the workflow when Run is clicked. No special configuration is required.
Configuration: {}
Manual Trigger → HTTP Request
Starts a workflow when the backend receives a request. After saving, open the Webhook node to copy its generated URL.
Example request:
Invoke-RestMethod `
-Method Post `
-Uri "http://localhost:8080/api/webhook/WORKFLOW_ID" `
-ContentType "application/json" `
-Body '{"userId":42,"email":"person@example.com"}'Replace WORKFLOW_ID with the real workflow ID.
The request body becomes the trigger payload available to downstream nodes.
Configure the method, URL, headers, and body in the inspector. The backend configuration also supports optional queryParams; headers, query parameters, and body must be valid JSON.
Example GET request:
Method: GET
URL: https://api.open-meteo.com/v1/forecast?latitude=28.6139&longitude=77.2090¤t=temperature_2m,relative_humidity_2m,wind_speed_10m&timezone=auto
Headers: {}
Body: {}
Equivalent configuration shape:
{
"method": "POST",
"url": "https://api.example.com/users",
"queryParams": { "source": "workflow" },
"headers": { "Content-Type": "application/json" },
"body": { "name": "Example User" }
}Example POST body:
{
"model": "your-model",
"messages": [
{ "role": "user", "content": "What is Java?" }
]
}Do not commit real API keys or place production secrets in this README. The HTTP executor sends configured header and body values as provided; it does not interpolate environment variables or workflow placeholders for authorization.
Transform selects, renames, creates, removes, and normalizes fields from upstream items. Supported operations include SELECT_FIELD, RENAME, SET_FIELD, REMOVE_FIELD, UPPERCASE, LOWERCASE, TRIM, EXTRACT_DOMAIN, and MAP_FIELDS.
Example SET_FIELD configuration:
{
"operations": [
{
"type": "SET_FIELD",
"targetField": "source",
"value": "automation"
}
]
}Example MAP_FIELDS configuration:
{
"operations": [
{
"type": "MAP_FIELDS",
"mappings": {
"city": "$.body.body.name",
"temperature": "$.body.body.main.temp"
}
}
]
}Always inspect the previous node's Output panel before writing a path. Use $ at the beginning, the actual fields in the upstream item, and array indexes such as [0] when needed. If a Merge node uses NAMESPACE, its configured namespaces become part of the item path.
Routes data through true or false.
Example configuration:
Input field: status
Operation: EQUALS
Expected value: approved
Connect the two output handles to different downstream nodes when both branches are needed.
Combines multiple incoming branches. Supported modes are APPEND, COMBINE, CHOOSE_BRANCH, and NAMESPACE.
Example combine configuration:
{
"mode": "COMBINE",
"combineBy": "MATCHING_FIELD",
"matchingField": ["email"],
"conflictPolicy": "PREFER_INPUT_1",
"keepUnmatched": true
}conflictPolicy can be PREFER_INPUT_1, PREFER_INPUT_2, or ERROR. CHOOSE_BRANCH selects one input, while NAMESPACE keeps both inputs under separate names.
Example:
HTTP Request 1 ─┐
├─→ Merge → Transform
HTTP Request 2 ─┘
Pauses execution before the next node. Configure the duration in seconds.
The backend stores this value as milliseconds and accepts values from zero to five minutes.
Manual Trigger → Delay (5 seconds) → HTTP Request
Sends email through the configured backend Gmail SMTP account. to, subject, and body are required string values. The backend also supports optional cc, bcc, and isHtml fields.
Configuration shape:
{
"to": "recipient@example.com",
"subject": "Workflow result",
"body": "The workflow completed successfully.",
"cc": "copy@example.com",
"bcc": "hidden@example.com",
"isHtml": false
}The current inspector exposes the required fields directly. The optional fields can be included in the persisted node configuration when needed.
Gmail placeholders are resolved from the upstream input map. For an upstream field named answer, use {{answer}}. Nested map paths are supported, for example {{user.email}}. Map and collection values are serialized as JSON before insertion.
The Gmail username and app password belong in backend environment variables, not in the frontend or workflow JSON.
Sends a text message through the configured Telegram bot. chatId and message are required scalar values.
Example:
Weather report
City: {{city}}
Temperature: {{temperature}}°C
Condition: {{condition}}
Telegram also accepts the optional input. prefix, such as {{input.city}}. Placeholders resolve only top-level upstream input keys and are converted to text.
Configuration shape:
{
"chatId": "123456789",
"message": "Workflow completed for {{name}}"
}The Telegram bot token belongs in the backend environment, not in node configuration.
Manual Trigger → HTTP Request → Transform → Telegram
Transform mapping:
{
"operations": [
{
"type": "MAP_FIELDS",
"mappings": {
"temperature": "$.body.body.current.temperature_2m",
"humidity": "$.body.body.current.relative_humidity_2m",
"windSpeed": "$.body.body.current.wind_speed_10m"
}
}
]
}Telegram message:
Current weather
Temperature: {{temperature}}°C
Humidity: {{humidity}}%
Wind speed: {{windSpeed}} km/h
Manual Trigger → HTTP Request → Transform → Gmail
Transform mapping:
{
"operations": [
{
"type": "MAP_FIELDS",
"mappings": {
"answer": "$.body.body.choices[0].message.content"
}
}
]
}Gmail body:
The workflow generated this response:
{{answer}}
There is no separate save action required for normal use:
- Add or edit nodes.
- Connect the graph.
- Click Run.
- The frontend saves the graph when it is dirty.
- The backend starts an execution.
- The editor updates the execution status.
- Click a node to inspect its result.
Click a node after execution starts. The inspector shows:
- Input: data received from upstream nodes
- Configuration: editable node settings
- Output: the node result or error
Statuses include NOT RUN, RUNNING, SUCCESS, FAILED, and OUTCOME_UNKNOWN. If a node fails, inspect its output and the execution notification. Downstream nodes may not receive input after an upstream failure.
| Method | Endpoint | Purpose |
|---|---|---|
POST |
/api/create-workflow |
Create a workflow |
GET |
/api/workflows |
List workflows |
GET |
/api/workflow/{id} |
Load workflow metadata |
GET |
/api/workflow/{id}/nodes |
Load nodes |
GET |
/api/workflow/{id}/connections |
Load connections |
PUT |
/api/workflow/{id}/graph |
Save the graph |
POST |
/api/workflow/{id}/execution |
Start execution |
GET |
/api/execution/{id} |
Load execution status |
GET |
/api/execution/{id}/nodes |
Load node results |
POST |
/api/webhook/{id} |
Trigger a webhook workflow |
Check that the backend is running, VITE_API_BASE_URL is correct, FRONTEND_URL matches the frontend origin, and PostgreSQL is available. Restart Vite after changing .env.
Check that a workflow is open, the backend is reachable, the graph contains valid node types, HTTP nodes have a method and URL, JSON fields are valid, and connections point to existing nodes.
Check the method, URL scheme, JSON syntax, authentication, API field names, and external API availability.
Compare the mapping path with the actual previous-node output. A wrong namespace, an extra .body, or an incorrect array index can produce an empty value.
Check the corresponding backend environment variables, recipient/chat ID, and template field names. Gmail requires an app password rather than the normal account password.
- Keep
.envfiles out of version control. - Never commit API keys, SMTP passwords, database passwords, or bot tokens.
- Use placeholders in examples.
- Do not log authorization headers or secret values.
- Rotate credentials that were accidentally exposed.
- Treat webhook endpoints as public entry points and validate incoming data in production.
Backend:
cd Backend
.\mvnw.cmd spring-boot:runFrontend:
cd Frontend
npm run dev
npm run build
npm run lintThe project currently focuses on visual workflow construction, persistence, execution, and node-level result inspection. Some workspace navigation entries may remain presentation-only until their corresponding backend features are connected. Actual node behavior is defined jointly by the backend execution engine and the frontend configuration forms.
