Camunda Platform 8:
├── Architecture: Cloud-native, distributed (Zeebe engine)
├── Licensing: Source-available (Camunda License), SaaS, Enterprise
├── Execution Model: Asynchronous job workers
├── Scaling: Horizontal (add brokers/workers)
├── Primary Use: High-throughput process orchestration
└── Target: Cloud-native microservices architectures

Flowable:
├── Architecture: Embedded Java engine
├── Licensing: Apache 2.0 (Community), Commercial (Work/Engage)
├── Execution Model: Synchronous/Async executors
├── Scaling: Vertical (larger JVM) + clustering
├── Primary Use: Traditional BPM and case management
└── Target: Java/Spring applications, traditional enterprise

Camunda 8 (Distributed):

   Client App          Zeebe Cluster           Workers
       │                    │                     │
       │    gRPC/REST      │                     │
       ▼                    ▼                     ▼
┌─────────────┐     ┌─────────────┐      ┌─────────────┐
│   Start     │────▶│   Broker    │◀────▶│   Worker    │
│  Process    │     │   Broker    │      │   Worker    │
│             │     │   Broker    │      │   Worker    │
└─────────────┘     └─────────────┘      └─────────────┘
                           │
                           ▼
                    ┌─────────────┐
                    │Elasticsearch│  (History/Search)
                    └─────────────┘

Characteristics:
- Brokers replicate data via Raft consensus
- Workers poll for jobs (async)
- No shared database needed
- Horizontally scalable

Flowable (Embedded/Clustered):

        Application Cluster              Database
              │                             │
              ▼                             ▼
┌─────────────────────────────┐    ┌─────────────────┐
│      App Instance 1         │    │                 │
│  ┌───────────────────────┐  │    │   PostgreSQL    │
│  │   Flowable Engine     │  │◀──▶│   (Shared DB)   │
│  │   - Process Engine    │  │    │                 │
│  │   - DMN Engine        │  │    │  - Process data │
│  │   - CMMN Engine       │  │    │  - History      │
│  └───────────────────────┘  │    │  - Jobs         │
└─────────────────────────────┘    │                 │
              │                    │                 │
              ▼                    │                 │
┌─────────────────────────────┐    │                 │
│      App Instance 2         │    │                 │
│  ┌───────────────────────┐  │◀──▶│                 │
│  │   Flowable Engine     │  │    │                 │
│  └───────────────────────┘  │    │                 │
└─────────────────────────────┘    └─────────────────┘

Characteristics:
- Embedded in application
- Shared database for clustering
- Async executor for background jobs
- Vertically scalable primarily

Camunda 8 excels when:
├── High throughput required (>1000 processes/sec)
├── Processes are long-running with many wait states
├── Multiple services need to orchestrate work
└── Cloud-native deployment is required

Flowable excels when:
├── Low latency is critical
├── Processes are short-lived
├── Tight integration with Java application
└── Simpler operational model preferred

Camunda Licensing:

Community Edition (Zeebe):
├── Source-available (Camunda License)
├── Free for development and internal use
├── Restrictions on offering as managed service
└── Limited to Zeebe engine (no Operate, Optimize)

Self-Managed Enterprise:
├── Full platform (Operate, Tasklist, Optimize)
├── Commercial license required
├── Annual subscription based on cores/clusters
└── Starting ~$50K/year (varies by deployment)

SaaS (Camunda Cloud):
├── Fully managed
├── Pay-per-use or reserved capacity
├── Starting ~$1K/month for small workloads
└── Scales with usage

Flowable Licensing:

Community Edition:
├── Apache 2.0 License
├── Fully open source
├── Complete BPMN, DMN, CMMN engines
├── No restrictions on commercial use
└── Community support only

Work (Enterprise):
├── Commercial license
├── Advanced modeling tools
├── Enterprise support
└── Contact for pricing

Engage (Low-code):
├── Commercial license
├── Citizen developer platform
├── Pre-built applications
└── Contact for pricing

Camunda 8 Connectors:
├── REST Connector (HTTP calls)
├── Kafka Connector
├── AWS (SQS, SNS, Lambda)
├── Google Cloud (Pub/Sub, Functions)
├── Slack, SendGrid, etc.
└── Custom connectors via SDK

Flowable Integrations:
├── Spring Boot (native)
├── Spring Security
├── JPA/Hibernate
├── Message queues (JMS, AMQP)
├── Email (JavaMail)
└── Custom via Java delegates

Camunda 8 Observability:
├── Operate (process monitoring)
├── Optimize (analytics)
├── Prometheus metrics
├── Structured logging
└── OpenTelemetry support

Flowable Observability:
├── Admin application
├── History service queries
├── JMX metrics
├── Spring Actuator integration
└── Custom dashboards needed

✅ High throughput (>1000 processes/second)
✅ Cloud-native/Kubernetes deployment
✅ Microservices orchestration
✅ Long-running processes with many wait states
✅ Need for horizontal scaling
✅ Polyglot workers (Node.js, Go, Python)
✅ Managed service preferred (SaaS)

✅ Open source requirement (Apache 2.0)
✅ CMMN case management needed
✅ Embedded engine in Java application
✅ Lower operational complexity preferred
✅ Traditional enterprise deployment
✅ Budget constraints
✅ Tight Java/Spring integration

❌ CMMN is required
❌ Tight Java embedding needed
❌ Very low latency critical (<5ms)
❌ Simple, low-volume workflows
❌ No Kubernetes/cloud infrastructure

❌ Need >5000 processes/second
❌ Cloud-native architecture required
❌ Non-Java workers needed
❌ Managed service required
❌ Horizontal scaling critical

Migration Path:
├── Process models: Re-export with Zeebe extensions
├── Java delegates: Convert to job workers
├── Expressions: JUEL → FEEL
├── History queries: API changes
├── Forms: Migrate to Camunda Forms
└── Effort: Significant rewrite

Migration Path:
├── Process models: Minor adjustments
├── Java delegates: Similar patterns
├── Expressions: JUEL compatible
├── History queries: Similar API
├── Forms: Rebuild in Flowable Forms
└── Effort: Moderate