Automated Pipeline System

What problem will this feature address?

Currently, Dokploy users need to manually orchestrate multiple steps when deploying applications, including running tests, creating new versions, and executing deployment commands. This manual process is time-consuming, error-prone, and lacks consistency across environments and team members. Teams need to create custom scripts or use external CI/CD tools to automate these workflows, adding complexity to the deployment process and requiring context switching between different tools.

Describe the solution you'd like

An integrated pipeline system within Dokploy that allows users to define, configure, and run automated workflows. The pipeline would:

• Support defining sequential and parallel execution steps
• Provide built-in actions for common operations (testing, versioning, building, deploying)
• Allow custom script execution within the pipeline
• Include conditional logic to handle success/failure of previous steps
• Offer pipeline templates for common deployment patterns
• Provide a visual editor and YAML configuration options
• Include detailed logging and execution history
• Support triggering pipelines on events (git push, scheduled, manual)
• Allow environment-specific pipeline configurations

This would create a seamless experience where developers can define their entire workflow within Dokploy without requiring external tools.

Describe alternatives you've considered

• Integration with existing CI/CD platforms (GitHub Actions, GitLab CI, Jenkins)
• Creating a plugin system that allows Dokploy to connect with external workflow engines
• Developing bash/PowerShell script templates that users can customize
• Using Docker Compose or Kubernetes-based orchestration with custom configurations

While these alternatives could work, they either require context switching between tools or significant manual configuration. An integrated pipeline system would provide a more cohesive and user-friendly experience.

Additional context

The pipeline system should be lightweight enough for simple projects but scalable for complex enterprise deployments. Users should be able to set up pipelines in two complementary ways:

1. Visual Block-Based Editor - Similar to React Flow, allowing users to drag-and-drop pipeline components and visually connect them, making it intuitive to design complex workflows without writing code. This would be ideal for teams with varying technical expertise.

2. YAML Configuration - For developers who prefer code-based configuration, a YAML format that can be version-controlled and easily shared across teams.

Both approaches should be fully interoperable - changes made in the visual editor would update the YAML file and vice versa.

A minimal YAML example could look like:

pipeline:
  name: deploy-app
  triggers:
    - manual
    - git-push: main
  steps:
    - name: run-tests
      command: bun test
    - name: bump-version
      command: bun run version-bump
      type: semver
      increment: minor
    - name: build
      command: bun run build
    - name: deploy
      command: dokploy deploy --env production
      condition: ${{ steps.run-tests.status == 'success' }}

Will you send a PR to implement it?

No

No files, tests, or entry points are named. Start by scoping the existing deployment and CI/CD architecture before defining how visual editing, YAML configuration, triggers, execution, logging, and history fit together. Done would require an agreed implementation scope covering the requested pipeline capabilities and interoperability.