.png)
SAP Signavio Integration Guide
Integrate SAP Signavio process content, governance data, and process-intelligence workflows with enterprise systems through product-specific APIs, scheduled synchronization, and selected event mechanisms.
SAP Signavio integration options at a glance
SAP Signavio integrations should be designed around the specific product, API version, tenant region, and permission model. REST APIs are the primary integration mechanism for process content and related operations. Product-specific callbacks or notifications may be available for selected events, but universal webhook coverage is not confirmed. Import, export, bulk, asynchronous, and file-based capabilities may also vary by product. Martini can consume documented Signavio APIs, manage tenant-specific authentication, process JSON, XML, BPMN, and CSV payloads, orchestrate related SAP or third-party calls, and use scheduled workflows with stored watermarks when event delivery is unavailable.
| Integration point | Supported by SAP Signavio? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Product-specific REST APIs can support process models, folders, metadata, governance content, or process-intelligence operations depending on the selected Signavio product and API version. | Martini can consume documented REST endpoints, handle JSON responses, paginate through results, transform payloads, and expose controlled REST APIs for downstream systems. |
| Authentication | Limited | OAuth 2.0, bearer tokens, API credentials, or service-user authentication may be available, subject to the product, tenant, region, and permission model. | Martini stores client secrets, API keys, tokens, base URLs, and scopes in environment-specific configuration and secrets rather than embedding them in workflows. |
| Webhooks / outbound callbacks | Limited | Selected Signavio products may provide notifications, callbacks, subscriptions, or event-oriented capabilities, but universal coverage across objects and events is not confirmed. | Martini can expose an authenticated API endpoint to receive supported callbacks, validate and transform payloads, and route unsupported or duplicate events safely. |
| Bulk / asynchronous / batch APIs | Limited | Import, export, asynchronous jobs, or batch operations may be available for selected products, but no suite-wide bulk API was confirmed. | Martini can orchestrate job submission and polling, stage large payloads, control concurrency, and reconcile completed, failed, and retried items. |
| File / attachment APIs | Limited | Process content may use BPMN, XML, CSV, or other import and export formats, although a general file or attachment API across the suite was not confirmed. | Martini can process documented files, transform structured content, and stage or deliver files through supported endpoints without assuming a universal Signavio file service. |
| Scheduled synchronization | Yes | Scheduled polling is an appropriate fallback when the selected Signavio product does not expose the required event or callback mechanism. | Martini scheduler workflows can retrieve changed objects using timestamps, versions, cursors, or identifiers and persist a watermark in a controlled store. |
| Database / analytics access | No | Direct SQL access to the managed SAP Signavio SaaS persistence layer was not confirmed and should not be used as an integration assumption. | Martini can use documented APIs or imports and can connect to an independently managed staging database when that database is part of the architecture. |
How SAP Signavio exposes data and business events
SAP Signavio REST APIs
REST is the primary confirmed integration mechanism for SAP Signavio, although available resources and operations depend on Process Manager, Process Governance, Process Intelligence, or another selected product. The API version, tenant region, permissions, and supported object model must be confirmed before implementation.
Martini implementation pattern
Martini implementation pattern: Martini authenticates against the product-specific endpoint, retrieves or submits the required resources, handles pagination and response validation, maps Signavio objects to a canonical model, and persists synchronization state outside the transient workflow payload.
Implementation sequence
SAP Signavio callbacks and notifications
Some Signavio products may provide callbacks, notifications, subscriptions, or event-oriented capabilities, but a universal webhook framework was not confirmed. Event names, delivery guarantees, retries, signatures, and duplicate behavior must be verified for the selected product.
Martini implementation pattern
Martini implementation pattern: Where a documented callback exists, Martini exposes an authenticated API endpoint, validates the incoming request, retrieves the current Signavio resource when necessary, and routes the event through a workflow. If no callback is available, a scheduler workflow uses incremental polling instead.
Implementation sequence
SAP Signavio imports, exports, and files
Process-related integrations may use BPMN, XML, CSV, or other documented import and export formats. Bulk and file capabilities vary by product, and a general-purpose attachment API across the suite was not confirmed.
Martini implementation pattern
Martini implementation pattern: Martini receives or retrieves the documented export, parses the relevant format, validates required identifiers and schema values, transforms the content for the target system, and records the source version for repeatable processing.
Implementation sequence
Scheduled SAP Signavio synchronization
Scheduled polling is the principal fallback when the selected Signavio product does not expose the required event or callback mechanism. Synchronization can use a modification timestamp, stable cursor, version, or identifier when supported by the API.
Martini implementation pattern
Martini implementation pattern: A scheduler starts a workflow that reads the stored watermark, retrieves changed objects with an overlap window, deduplicates by object and version, applies mappings and business rules, writes target changes, and advances the watermark only after successful processing.
Implementation sequence
Common SAP Signavio integration patterns
Pattern 1: Publish approved process models to an enterprise repository
When to use this pattern
Use this pattern when approved Signavio process models and metadata must be published to an intranet, document repository, service catalog, or process portal. The workflow should limit synchronization to approved folders, statuses, or versions and avoid creating duplicate documents after retries.
Integration direction
Example Mapping
| SAP Signavio Field | Canonical Field | Target Field |
|---|---|---|
| Process model ID | sourceProcessId | externalReference |
| Process model name | processName | name |
| Process attributes.status | lifecycleStatus | approvalStatus |
| Process attributes.owner | processOwner | owner |
Martini implementation pattern
Martini polls the documented Signavio API or receives a supported notification, retrieves the current model metadata, validates approval and ownership rules, transforms the result into the repository or catalog schema, and performs an idempotent upsert. Temporary failures are retried with bounded backoff, while rejected mappings are routed to reconciliation.
Martini capabilities used
- workflows
- API consumption
- scheduling
- data mapping
- business rules
- error handling
Pattern 2: Synchronize governance requests with ServiceNow
When to use this pattern
Use this pattern when Process Governance requests, approvals, or improvement actions need to be coordinated with ServiceNow workflow management. The exact Signavio object names and write operations must be confirmed for the selected Process Governance API.
Integration direction
Example Mapping
| SAP Signavio Field | Canonical Field | Target Field |
|---|---|---|
| Governance request ID | requestId | correlationId |
| Request title | summary | shortDescription |
| Request owner | assignee | assignedTo |
| Request status | lifecycleStatus | state |
Martini implementation pattern
Martini retrieves new or changed requests, validates that the request is in scope, maps owners and statuses to ServiceNow values, and creates or updates the corresponding record. It stores the cross-system identifier, prevents duplicate creation after ambiguous timeouts, and sends permitted status changes back to Signavio.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- idempotency
- error handling
Pattern 3: Orchestrate SAP process context for Signavio analysis
When to use this pattern
Use this pattern when Signavio process models or Process Intelligence ingestion require operational context from SAP S/4HANA, SAP ECC, or another enterprise application. It is suitable for controlled, scheduled loads where identifiers, timestamps, and event or case keys must be normalized.
Integration direction
Example Mapping
| SAP Signavio Field | Canonical Field | Target Field |
|---|---|---|
| SAP business object ID | businessObjectId | caseId |
| SAP event type | eventName | activity |
| SAP posting timestamp | eventTimestamp | timestamp |
| SAP organizational unit | organizationCode | organizationalUnit |
Martini implementation pattern
Martini retrieves operational data through documented SAP interfaces, normalizes identifiers and timestamps, applies privacy and completeness rules, and submits the documented Signavio ingestion or process-context payload. For large loads, the workflow can stage data, poll asynchronous jobs, and retain failed item identifiers for reprocessing.
Martini capabilities used
- workflow orchestration
- API consumption
- data transformation
- validation
- scheduled execution
- reconciliation
Pattern 4: Synchronize process changes with incremental polling
When to use this pattern
Use this pattern when no suitable Signavio callback is available or when event coverage is limited. It supports model, folder, dictionary, or governance synchronization using a durable watermark and periodic reconciliation.
Integration direction
Example Mapping
| SAP Signavio Field | Canonical Field | Target Field |
|---|---|---|
| lastModified | modifiedAt | sourceModifiedAt |
| Object ID | sourceObjectId | externalId |
| Version | sourceVersion | version |
| Object type | objectType | recordType |
Martini implementation pattern
A Martini scheduler reads the last successful watermark from a controlled database, retrieves changed objects with pagination and an overlap window, deduplicates by identifier and version, maps changes to the target model, and advances the watermark only after successful completion. Full reconciliation can identify missed, deleted, or conflicting objects.
Martini capabilities used
- scheduler workflows
- API consumption
- database access
- data mapping
- idempotency
- monitoring and reconciliation
Applications commonly integrated with SAP Signavio
SAP Signavio commonly participates in process-transformation architectures that connect process models, governance activities, operational data, and improvement work. Each integration must be validated against the selected Signavio product and documented API surface.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| SAP S/4HANA | Align process models and performance context with operational transactions, organizational data, and enterprise process execution. | SAP S/4HANA → Martini → SAP Signavio | Martini consumes documented S/4HANA and Signavio APIs, normalizes organizational or operational context, applies product-specific business rules, and synchronizes approved process metadata or analysis inputs with idempotent workflows. |
| SAP ECC | Provide process and operational context from legacy SAP ERP environments used alongside Signavio transformation initiatives. | SAP ECC → Martini → SAP Signavio | Martini retrieves selected ECC data through documented interfaces, maps it to the Signavio process or analysis model, stages large transfers when required, and records watermarks and reconciliation results. |
| SAP Ariba | Relate procure-to-pay process documentation and analysis to procurement events and supplier workflows. | SAP Ariba → Martini → SAP Signavio | A Martini workflow retrieves approved procurement data from documented endpoints, normalizes identifiers and timestamps, and submits the required process-intelligence or process-context payload while handling validation and asynchronous processing. |
| SAP SuccessFactors | Connect employee-related process models with workforce and organizational context where HR process transformation requires it. | SAP SuccessFactors → Martini → SAP Signavio | Martini orchestrates SuccessFactors and Signavio API calls, filters sensitive attributes, maps organizational references, and routes rejected or incomplete payloads to controlled error handling. |
| Salesforce | Link customer, sales, and service process documentation or governance with CRM execution data. | Salesforce → Martini → SAP Signavio | Martini polls or consumes supported Salesforce interfaces, maps selected business events to Signavio process context, and uses stable source identifiers to prevent duplicate submissions. |
| ServiceNow | Synchronize process governance actions, change records, or improvement initiatives with enterprise workflow management. | SAP Signavio → Martini → ServiceNow | Martini reads eligible governance requests, maps owners, priorities, statuses, and references to ServiceNow records, then returns permitted status changes to Signavio using idempotent upserts and bounded retries. |
| Jira | Track process-improvement tasks, remediation actions, or implementation work associated with Signavio models. | SAP Signavio → Martini → Jira | A Martini workflow creates or updates Jira issues from approved Signavio governance data, stores the cross-system identifier, and synchronizes selected task status changes back when the Signavio API permits it. |
| Celonis | Coordinate process-mining outputs and process-management artifacts where both platforms are used in a transformation architecture. | Celonis → Martini → SAP Signavio | Martini exchanges only the documented analytical or process metadata required by each platform, normalizes case and event identifiers, and isolates product-specific API and licensing assumptions behind reusable workflows. |
How to build a SAP Signavio integration in Martini
Objective
Identify the Signavio product and API surface, then configure tenant-specific endpoints, authentication, scopes, and permissions without hard-coding secrets or regional URLs.
Instructions in Martini
- Confirm the Signavio product, API version, tenant region, and required operations
- Configure OAuth 2.0, bearer-token, API-credential, or service-user authentication as documented
- Store credentials, tokens, scopes, and base URLs in environment-specific Martini configuration
- Apply least-privilege permissions and restrict sensitive payload logging
Objective
Select event-driven processing only when the specific Signavio product documents a suitable callback or notification; otherwise use scheduled incremental synchronization.
Instructions in Martini
- Verify event names, delivery guarantees, signatures, and retry behavior before using callbacks
- Expose a secured Martini API endpoint for supported outbound requests
- Configure a scheduler workflow when callbacks are unavailable or incomplete
- Define the watermark, overlap window, and reconciliation interval
Objective
Retrieve the current Signavio resource or process an approved import, export, or asynchronous operation while respecting pagination, payload size, and tenant limits.
Instructions in Martini
- Call the documented REST endpoint for the selected product
- Handle cursors, pages, stable identifiers, and asynchronous job polling
- Retrieve current resources after notification events when the event contains only a reference
- Stage large BPMN, XML, CSV, or analytical payloads when required
Objective
Use a Martini workflow to coordinate Signavio calls, related SAP or third-party APIs, persistence, business rules, and target-system writes as one maintainable integration process.
Instructions in Martini
- Separate product-specific API calls from reusable orchestration logic
- Branch for validation failures, missing objects, authorization errors, throttling, and temporary service failures
- Persist synchronization state, cross-system identifiers, and reconciliation summaries
- Use bounded retries and avoid advancing checkpoints after partial failure
Objective
Convert Signavio process models, folders, attributes, governance requests, or analytical data into a canonical model and the target application's schema.
Instructions in Martini
- Map stable Signavio identifiers and versions to canonical fields
- Normalize timestamps, time zones, enumerations, owners, and status values
- Transform JSON, XML, BPMN, CSV, or other documented formats as required
- Validate required fields and quarantine unexpected custom attributes
Objective
Ensure only approved, in-scope, and complete content is synchronized while protecting sensitive process and organizational information.
Instructions in Martini
- Filter by folder, status, product scope, version, or governance state
- Apply approval, ownership, privacy, and completeness rules
- Prevent duplicate documents, tickets, cases, or analytical submissions
- Route rejected records to a review or reconciliation path
Common SAP Signavio data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Process models | BPMN or related process diagrams used to document, communicate, govern, and analyze business processes. | Document repositories, service catalogs, intranets, process portals, and process-analysis platforms | Martini retrieves model metadata or documented content, validates versions and attributes, transforms the payload, and upserts the target representation using the model identifier. |
| Folders | Organizational containers for process models and related process content, particularly in Process Manager scenarios. | Document repositories, knowledge platforms, service catalogs, and governance applications | Martini synchronizes selected folder hierarchies, maintains parent-child references, and applies filtering rules for approved or in-scope content. |
| Dictionaries | Reusable terminology and reference elements such as systems, roles, risks, and other modeled objects. | Master-data stores, governance platforms, catalogs, and reporting systems | Martini maps dictionary identifiers and types to a canonical reference model and detects additions, changes, and removals during reconciliation. |
| Process attributes | Classifications, ownership, status, and custom metadata associated with process models. | Service catalogs, reporting platforms, document repositories, and governance systems | Martini validates required and optional attributes, normalizes enumerations, and routes unexpected custom fields to controlled mapping or quarantine logic. |
| Process governance requests | Requests or cases that move through configured governance workflows in Process Governance scenarios. | ServiceNow, Jira, Salesforce, approval applications, and reporting systems | Martini maps request identifiers, owners, priorities, and statuses, applies idempotent upserts, and synchronizes permitted status updates. |
| Process Intelligence data and investigations | Analysis-oriented data and investigation objects used to examine process performance and operational behavior. | Data platforms, reporting systems, SAP applications, and process-improvement tools | Martini prepares, normalizes, and submits or retrieves documented analytical payloads while accounting for volume, asynchronous processing, identifiers, timestamps, and reprocessing. |
Authentication and security considerations
Product-specific authentication
SAP Signavio is a suite rather than one uniform API. Confirm the selected product, API version, tenant region, authentication flow, scopes, and roles before implementation.
- OAuth 2.0 and bearer tokens may be available for current cloud APIs.
- API credentials or service-user authentication may apply to some legacy or product-specific APIs.
- Tenant endpoints, client secrets, tokens, and API keys should be stored in Martini environment configuration and secrets.
- Use least-privilege Signavio permissions and restrict logs containing process, employee, customer, supplier, risk, or compliance information.
Operational considerations for SAP Signavio integrations
Reliability and lifecycle concerns
- Confirm tenant-specific quotas, page sizes, rate limits, and asynchronous processing behavior.
- Handle HTTP 429 responses with Retry-After when provided, bounded retries, exponential backoff, and controlled concurrency.
- Persist watermarks outside transient workflow payloads and use overlap windows with deduplication for polling.
- Use stable model, request, object, and version identifiers for idempotency and reconciliation.
- Validate optional attributes, custom fields, enumeration values, and API-version changes instead of silently dropping unfamiliar data.
- Test large model and analytical payloads, schema changes, deleted objects, ambiguous timeouts, and partial failures.
Why use Martini instead of scripts or point-to-point integrations?
A maintainable integration layer
Direct scripts can connect to an API, but they often leave authentication, checkpointing, retries, mapping, monitoring, and related-system orchestration embedded in application-specific code.
- Martini separates workflows, API calls, mappings, business rules, and environment configuration.
- It can combine Signavio APIs with SAP, ServiceNow, Jira, databases, files, and other enterprise endpoints.
- Reusable workflows support scheduled, event-driven, API-led, and asynchronous integration patterns.
- Centralized validation, error handling, retry logic, reconciliation, and monitoring improve operational reliability.
- Martini can expose a controlled API façade when consumers should not access Signavio directly.
Frequently asked questions
SAP Signavio can be integrated primarily through product-specific REST APIs. Depending on the selected product, integrations may also use documented imports, exports, asynchronous operations, files, or limited callbacks and notifications. Scheduled polling is an appropriate fallback when event delivery is unavailable.
Yes. Martini can consume documented SAP Signavio REST APIs, manage product- and tenant-specific authentication, transform JSON, XML, BPMN, and CSV payloads, orchestrate related SAP or third-party calls, and expose controlled REST endpoints for supported callbacks or downstream integrations.
No. A dedicated SAP Signavio connector is not required. Martini can use SAP Signavio's documented REST APIs, supported authentication methods, imports, exports, files, and product-specific callbacks or notifications where available.
Lonti does not charge an additional per-connector or per-vendor fee to integrate SAP Signavio. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from SAP Signavio, SAP, cloud infrastructure, or other third-party systems depending on subscriptions, usage, and deployment model.
REST APIs are the primary recommended mechanism, subject to the specific Signavio product and API version. Imports, exports, asynchronous operations, and file-based processing may be suitable for selected use cases. GraphQL and current SOAP APIs were not confirmed and should not be assumed.
Some Signavio products may provide callbacks, notifications, subscriptions, or event-oriented capabilities, but universal webhook support was not confirmed. Event availability, delivery guarantees, signatures, retries, and supported objects must be verified for the selected product. Martini can use scheduled polling when events are unavailable.
Martini can synchronize selected process models, folders, dictionaries, attributes, governance requests, or analytical data through API retrieval and idempotent writes. Incremental synchronization should use a supported timestamp, cursor, version, or identifier, with a stored watermark, overlap window, pagination, and periodic reconciliation.
Martini maps Signavio payloads into canonical and target-specific models, validates required fields, normalizes timestamps and enumerations, and applies business rules before writing. Workflows can use stable object and version identifiers for idempotency, bounded retries for transient failures, throttling for rate limits, and reconciliation paths for rejected or ambiguous results.
Related Martini documentation
Workflows
Data handling
Connect SAP Signavio with your enterprise systems
Use Martini to build maintainable SAP Signavio integrations around documented APIs, scheduled workflows, controlled callbacks, data transformation, and enterprise-grade operational handling.