Building blocks for
every process step

Decisions, human judgment, system integrations, and custom logic. The composable steps behind every process you run, working under one governance model alongside your AI agents.

Talk to salesTry free
Process orchestration building blocks illustration

Composable by design

Every step in a Camunda process is a composable building block. Rule-based decisions for the predictable cases, with policy owners able to change rules without writing code. Structured human tasks with full case context and SLA visibility. Pre-built connectors to hundreds of enterprise systems. Custom code workers in the languages your team already uses.

Mix them in any order, in any process. They all run under the same governance, the same audit trail, and the same observability layer. A process that uses every step type stays as governable as one that uses just one.

Decision automation

Rule-based decisions that are deterministic, auditable, and editable by the people who own the policy.

Human in the loop

Structured handoffs to people, with full context and an SLA, when the decision needs judgment instead of speed.

Integrations

Pre-built connectors to hundreds of enterprise systems, plus deep integrations for SAP and ServiceNow.

RPA

Embed RPA bots in end-to-end processes to automate legacy systems, with full visibility and easy handoffs to APIs or agents when ready.

Intelligent document processing

Classify, extract, and validate data from any document type using AI and OCR, feeding results directly into decisions and human review.

Custom code

Job workers in Java, Go, Python, Node.js, and more. The differentiated logic only your team can write.

Decision automation

Some choices in your business are about judgment. Most are about applying rules consistently. Loan eligibility. Claim routing. Pricing tiers. Risk scoring. Eligibility for straight-through processing. These are decisions where you want the same answer every time and a clear record of why.

Camunda’s decision engine evaluates business rules at runtime and returns deterministic, auditable outcomes. Rules live in tables that the team responsible for the policy can read and change directly, with no code change and no deployment required. The decision is documented, regulator-defensible, and editable by the people who own it. You can trace exactly which rule applied, what data drove it, and when it last changed.

Explore the decision engine
Example decision

Loan eligibility for straight-through processing

A rules table evaluates application data against current policy and returns an eligibility outcome that the process can act on.

  • Loan amount under €100,000
  • Credit score above 720
  • Debt-to-income ratio below 35%
  • Employment verified through connector
  • Outcome: auto-approve or route to underwriter

Human in the loop

The decisions that reach a person are the hard ones. The loan above the auto-approval threshold. The claim with conflicting evidence. The exception an agent escalated because it wasn’t confident. As AI does more of the work, the role of the human in the loop becomes more important, not less.

When a process reaches a step that needs a person, Camunda creates a structured task with full context: what happened before, what comes next, what decision is needed right now. Operations teams get one workspace for every human task across every process, with SLA visibility and a complete audit trail by default. When a task follows an agent step, the agent’s reasoning travels with the case.

Explore human in the loop
Example human task

Senior credit officer review

A loan above €500,000 routes to a senior credit officer. The process pauses, waits, and resumes when the decision is recorded.

  • Full case history visible without switching tools
  • Forms that surface only what’s needed for this step
  • SLA visible before deadlines are at risk
  • One-click escalation when authority is needed
  • Audit trail by default, no manual logging

Integrations

Every business process touches systems your team didn’t build. CRM. ERP. Core banking. Document management. Identity verification. Credit bureaus. The agent frameworks. Camunda connectors handle these integrations as standard process steps, with credentials in centralized secrets management, consistent retry and error handling, and one well-built integration shared across every process that needs it.

Hundreds of pre-built connectors in Camunda Marketplace cover the systems most enterprises run on. Open standards like MCP and A2A make it possible to connect agents from any framework without custom integration work. When you need something that doesn’t exist yet, your team can build a custom connector once and publish it to Marketplace for the rest of the organisation to reuse.

Browse Camunda Marketplace
Examples of connectors
  • Communication — Slack, Microsoft Teams, SendGrid, Twilio
  • CRM & sales — Salesforce, HubSpot
  • Cloud platforms — AWS (S3, SQS, Lambda), Google Cloud, Azure
  • Productivity — GitHub, GitLab, Jira, Confluence
  • AI & agents — OpenAI, Anthropic, Hugging Face
  • Messaging & streaming — Kafka, RabbitMQ, NATS
  • Automation — REST, GraphQL, SOAP, webhook
SAP integration

Orchestrate SAP end-to-end

SAP is your system of record. Camunda runs the processes around it, connecting S/4HANA, ECC, and your non-SAP systems in one auditable, BPMN-based flow. Order-to-cash, procure-to-pay, and record-to-report, end-to-end across SAP and beyond.

  • Wrap SAP transactions in BPMN-based agentic processes
  • Coordinate SAP plus Salesforce, ServiceNow, and Workday in one process
  • AI agents from any framework, with full audit trails
  • De-risk S/4HANA migration: process logic stays portable
Explore SAP integration
ServiceNow integration

Coordinate ServiceNow beyond its perimeter

ServiceNow stays your system of record for tickets, requests, and CMDB. Camunda coordinates the end-to-end process around it, connecting the systems ServiceNow doesn’t own: Workday, SAP, identity providers, and your engineering stack.

  • Incident-to-resolution across ITSM and your engineering stack
  • Employee onboarding spanning HRSD, Workday, and identity
  • AI agents from any framework, orchestrated with a full audit trail
  • Process logic portable across Now Platform releases
Explore ServiceNow integration

Robotic process automation

Not every system has a modern API. Legacy applications, mainframes, and desktop tools are often wired into critical processes and can’t be replaced quickly. RPA lets you automate interactions with these systems exactly as a person would, navigating screens, extracting data from tables, and writing values back, without requiring the underlying application to change.

When RPA runs inside a Camunda process, bots are standard steps with the same visibility, error handling, and audit trail as any other step type. You can see which bots ran, what they did, and when they failed. When a system eventually gets a proper API, you swap the bot step for a connector step without redesigning the process. Modernisation at your own pace, without rebuilding from scratch.

Explore RPA orchestration
Example RPA step

Claims intake from legacy portal

A bot navigates the claims portal, extracts intake data, and feeds it into the Camunda process with no API required. When the portal is eventually modernised, only the step changes.

  • Bot runs as a standard step with no separate orchestration tool
  • Failures surface in the same ops view as every other step
  • Retry and error handling configured without custom code
  • Swap to an API connector when the system is ready
  • Full audit trail of every bot execution

Intelligent document processing

Documents arrive in every format and layout: invoices, contracts, claim forms, identity documents, medical records. Extracting structured data from them manually is slow, error-prone, and a bottleneck in almost every back-office process. Camunda’s IDP capability uses AI, OCR, and machine learning to classify, extract, and validate document data automatically.

Extracted data feeds directly into the next step of your process: a decision table, a human review task, or a connector that updates a downstream system. When confidence is low, the process routes to a human reviewer with the document and extracted values side by side. One customer automated 80–90% of document handling in their workflows. The rest gets the structured human review it actually needs.

Explore IDP
Example IDP step

Invoice processing, end to end

AI classifies the document, extracts line items and totals, validates against PO data, and routes exceptions to a reviewer, all as standard process steps.

  • Classifies structured, semi-structured, and unstructured formats
  • Extracts and validates data against rules and source systems
  • Low-confidence extractions route to human review automatically
  • Reviewer sees document and extracted values side by side
  • Validated data feeds directly into downstream decisions

Custom code

Some logic is unique to your business. Proprietary scoring models. Specialized validation. Bespoke calculations refined over years of operating in your industry. This logic doesn’t fit a pre-built pattern, and it shouldn’t. It’s where your competitive differentiation lives.

Camunda lets your developers implement custom steps as job workers in Java, Go, Python, Node.js, C#, Ruby, and more. Plug the worker into your process as a standard step and it inherits the same governance, retry behavior, and audit trail as every other step type. Your differentiated logic stays yours. The orchestration infrastructure stays standard.

Explore custom code workers
Example custom worker

Proprietary credit scoring

Bespoke credit scoring logic that incorporates alternative data sources, implemented as a job worker and plugged into the loan origination process as a standard step.

  • Written in your language of choice
  • Same governance as every other step
  • Automatic retries and error handling
  • Full audit trail of every invocation
  • Reusable across every process that needs it
“
We currently offer a mix of specialized technologies — modern UI/UX, portals, integration layers for modern and legacy applications, RPA, machine learning. Camunda adds business orchestration to the mix, allowing us to fuse these technologies together to create truly digitalized processes.

Dr. Leander Fiedler

Automation Lead, NORD/LB

Frequently asked questions

What are the building blocks of a Camunda process?
Every step in a Camunda process draws from the same library: AI agents for reasoning and adaptation, decision automation for rule-based logic, human task patterns for steps that need judgment, connectors for system integrations, and custom code workers for proprietary logic. Each is a composable step you can add to a process model, and every step type runs under the same governance, audit trail, and observability layer.
How does decision automation differ from AI agents?
Decision automation evaluates business rules deterministically: the same inputs always produce the same outputs, the rules are documented in tables, and they can be audited and edited by the team that owns the policy. AI agents reason about ambiguous situations where rules can’t capture every case. Most enterprise processes use both. Deterministic decisions handle the predictable majority. Agent reasoning handles the genuinely complex cases. The two work together inside the same process model.
Can business teams change decision rules without IT?
Yes. Camunda’s decision engine uses Decision Model and Notation (DMN), a standard that expresses rules as tables business users can read. Policy owners can update rules, add conditions, or change thresholds without writing code or scheduling a deployment. The change is versioned, auditable, and live in production once approved.
How do connectors work with AI agents?
Camunda connectors expose enterprise systems as both standard process steps and as agent tools. The same Salesforce connector that updates a CRM record in a deterministic step can also be called by an AI agent. Open standards like MCP and A2A let any agent framework reuse the same governed integrations, so you build each integration once and use it everywhere. Credentials, retry logic, and audit are all centralized.
What programming languages does Camunda support for custom code?
Camunda supports custom job workers in Java, Go, Python, Node.js, C#, Ruby, and more. Pick the language and framework your team already uses. The worker plugs into your process as a standard step and inherits the same governance, retry behavior, and audit trail as every other step type. Your team writes the logic that’s unique to your business. The orchestration platform handles everything around it.
How does RPA fit into a Camunda process?
RPA bots run as standard steps inside a Camunda process model. They get the same error handling, retry logic, and audit trail as any other step type. You can monitor bot performance alongside every other step in the same operations view. When a legacy system eventually gets a proper API, you replace the bot step with a connector step without redesigning the process.
What document types does Camunda’s IDP support?
Camunda’s intelligent document processing handles structured, semi-structured, and unstructured document formats: invoices, contracts, claim forms, identity documents, medical records, and more. AI, OCR, and machine learning classify and extract data automatically. When confidence is below your threshold, the process routes to a human reviewer with the document and extracted values side by side before passing results to the next step.
Do all of these capabilities work together in one process?
Yes. A single process can combine AI agents, deterministic decisions, human tasks, connectors, and custom code workers in any order. A loan origination process might use a connector to pull a credit report, a decision table to check straight-through eligibility, an agent to evaluate non-standard income, a human task for high-value approvals, and a custom worker for proprietary risk scoring. One model, one audit trail, one source of truth across every step.

From building blocks to outcomes

Talk to salesTry free