.png)
Certinia Integration Guide
Certinia integrates with enterprise systems through Salesforce REST, SOAP, Bulk, file, and event APIs exposed by its Salesforce-native applications.
Certinia integration options at a glance
Certinia data is generally accessed through the Salesforce platform APIs because Certinia applications run natively on Salesforce. REST APIs support queries, creates, updates, deletes, and upserts for accessible Certinia package objects, while SOAP supports strongly typed enterprise integrations. Salesforce Bulk API supports asynchronous high-volume transfers, and Salesforce Files APIs handle documents through ContentVersion, ContentDocument, and ContentDocumentLink. Selected objects and processes may support Change Data Capture, Platform Events, Outbound Messages, or other callbacks, although event coverage is configuration-dependent. Martini can authenticate with Salesforce OAuth mechanisms, orchestrate workflows, map and validate data, expose APIs, and manage retries and reconciliation.
| Integration point | Supported by Certinia? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Yes | Query, create, update, delete, and upsert Salesforce and Certinia package objects such as Projects, Accounts, Timecards, and Expense Reports. | Martini can consume REST endpoints, manage authentication configuration, map payloads, apply business rules, and expose controlled APIs over Certinia data. |
| GraphQL APIs | Limited | Salesforce GraphQL can retrieve supported Salesforce data, but Certinia object and field coverage must be verified for each organization and use case. | Martini can consume GraphQL APIs and transform responses, while the implementation validates the required Certinia schema before production use. |
| SOAP APIs | Yes | Support strongly typed enterprise integrations and existing systems that use Salesforce enterprise WSDLs and generated client bindings. | Martini can consume SOAP services, handle XML payloads, map typed responses, and route SOAP faults through workflow error handling. |
| Bulk and asynchronous APIs | Yes | Perform high-volume ingestion, extraction, migration, warehouse exports, periodic updates, and reconciliation for eligible Certinia objects. | Martini can submit Bulk API jobs, retain job identifiers, poll status, retrieve successful and failed results, and process failures separately. |
| Webhooks and outbound callbacks | Limited | Salesforce Outbound Messages, Apex callouts, and related callback patterns can notify external systems for selected configured conditions. | Martini can receive webhook-style notifications and initiate workflows, but object coverage, delivery behavior, and configuration must be verified. |
| Events and change notifications | Limited | Platform Events and Change Data Capture can support event-driven synchronization for supported objects and enabled channels. | Martini can consume supported event or callback payloads, retrieve the current resource when necessary, and apply duplicate-safe processing. |
| File and attachment APIs | Yes | Transfer Salesforce Files through ContentVersion, ContentDocument, and ContentDocumentLink; legacy Attachment records may exist in older organizations. | Martini can retrieve or create file objects, preserve metadata and relationships, and transfer documents to downstream endpoints. |
| Authentication | Yes | OAuth 2.0 flows, JWT bearer flow, web-server flow, and other Salesforce connected-app configurations govern access to Certinia data. | Martini can use secure environment configuration and secrets for tokens, client credentials, certificates, and related authentication values. |
| Database access | No | Direct access to the underlying Certinia or Salesforce database is not the standard integration boundary; APIs and supported Salesforce data services should be used. | Martini can connect to separate databases or warehouses when supplied, but it should not assume direct Certinia database access. |
How Certinia exposes data and business events
Certinia REST APIs
Certinia package objects are exposed through the Salesforce REST API when the integration user has the required object, field, sharing, and package permissions. REST supports individual queries and mutations, including upserts where external IDs are available.
Martini implementation pattern
Martini implementation pattern: Martini authenticates with a Salesforce OAuth configuration, calls REST resources from workflows, follows pagination links, maps responses to canonical models, applies validation and business rules, and writes results to downstream systems or exposes a controlled Martini API.
Implementation sequence
Certinia Bulk APIs
Salesforce Bulk API supports asynchronous high-volume extraction and ingestion for eligible Certinia package objects. Jobs are submitted first and results are retrieved after Salesforce processes them.
Martini implementation pattern
Martini implementation pattern: A scheduled or on-demand workflow submits a Bulk API job, stores its identifier, monitors status, retrieves successful and failed results, and sends failures through controlled retry or reconciliation processing.
Implementation sequence
Certinia SOAP APIs
Salesforce SOAP API provides strongly typed access to accessible Salesforce and Certinia objects and remains relevant for existing enterprise integrations that depend on generated WSDL bindings.
Martini implementation pattern
Martini implementation pattern: Martini consumes the SOAP service, supplies the configured authentication and request envelope, transforms XML responses into internal structures, and handles SOAP faults separately from business validation errors.
Implementation sequence
Certinia events and callbacks
Salesforce Platform Events, Change Data Capture, Outbound Messages, Apex callouts, and related mechanisms can support selected Certinia event scenarios. Coverage depends on object support, package behavior, enabled channels, licensing, retention, and configuration.
Martini implementation pattern
Martini implementation pattern: Martini receives a supported notification, validates its event identity, retrieves the current Salesforce resource when required, and processes the event idempotently. Polling or scheduled incremental synchronization remains an alternative where event coverage is incomplete.
Implementation sequence
Certinia Files APIs
Salesforce Files uses ContentVersion, ContentDocument, and ContentDocumentLink to manage documents and their relationships. Legacy Attachment records may still be present in some organizations.
Martini implementation pattern
Martini implementation pattern: Martini retrieves or creates file content and metadata, preserves the parent relationship and version information, and transfers documents to a target endpoint while enforcing size, visibility, and retention rules.
Implementation sequence
Common Certinia integration patterns
Pattern 1: Hand off Salesforce opportunities to Certinia projects
When to use this pattern
Use this pattern when a Salesforce Opportunity reaching a defined stage should create or update a Certinia Project and related delivery records. It supports a controlled transition from sales to professional-services delivery.
Integration direction
Example Mapping
| Certinia Field | Canonical Field | Target Field |
|---|---|---|
| Opportunity.Id | sourceOpportunityId | Opportunity reference |
| AccountId | customerId | Account |
| CloseDate | plannedStartDate | Project start date |
| Amount | contractValue | Project financial value |
Martini implementation pattern
Martini receives a supported Salesforce event or runs an incremental query, validates required commercial and customer fields, checks for an existing project using a correlation key, and creates or updates the Certinia Project. Duplicate prevention, ownership mapping, permission failures, and retryable API errors are handled explicitly.
Martini capabilities used
- workflows
- API consumption
- data mapping
- business rules
- idempotency
- error handling
Pattern 2: Export approved timecards and expenses
When to use this pattern
Use this pattern to send approved Certinia Timecards and Expense Reports to payroll, accounting, or expense-processing applications without re-exporting previously accepted data.
Integration direction
Example Mapping
| Certinia Field | Canonical Field | Target Field |
|---|---|---|
| Timecard.Resource | workerId | employee |
| Timecard.Project | projectId | project |
| Timecard.Hours | quantity | billable hours |
| Expense Report.Total | expenseAmount | transaction amount |
Martini implementation pattern
A scheduled Martini workflow selects records in an approved state, maps worker, project, currency, tax, and source identifiers, submits them through the target API or file endpoint, and updates processing state only after confirmed success. Rejected lines, duplicate submissions, and transient failures are routed to retry and reconciliation paths.
Martini capabilities used
- scheduled workflows
- API consumption
- mapping and transformation
- validation
- business rules
- retry handling
Pattern 3: Synchronize projects, resources, and assignments
When to use this pattern
Use this pattern when Certinia delivery planning must remain aligned with a work-management or resource-planning application. Events can be used where supported; otherwise incremental queries and scheduled reconciliation provide coverage.
Integration direction
Example Mapping
| Certinia Field | Canonical Field | Target Field |
|---|---|---|
| Project.Name | projectName | project name |
| Resource.Id | resourceId | assignee identifier |
| Assignment.StartDate | assignmentStart | planned start |
| Assignment.EndDate | assignmentEnd | planned end |
Martini implementation pattern
Martini consumes supported change notifications or queries records using SystemModstamp or LastModifiedDate, matches identities and projects, converts dates and timezones, and applies system-of-record rules before writing Jira updates. Duplicate events, late changes, conflicts, and unavailable event coverage are handled through durable watermarks and reconciliation.
Martini capabilities used
- event-driven workflows
- scheduled synchronization
- data mapping
- watermarks
- business rules
- reconciliation
Pattern 4: Send billing events to finance and tax systems
When to use this pattern
Use this pattern when approved Certinia Billing Events or invoice-related data must be transferred to a finance, tax, or ERP platform and the resulting external identifier or error must be returned to Certinia.
Integration direction
Example Mapping
| Certinia Field | Canonical Field | Target Field |
|---|---|---|
| Billing Event.Id | sourceBillingEventId | source reference |
| Billing Event.Amount | netAmount | transaction amount |
| Billing Event.Currency | currencyCode | currency |
| Billing Event.Project | projectReference | project or job |
Martini implementation pattern
A Martini workflow retrieves approved billing data, validates accounting period and posting status, transforms decimal, currency, tax, and project values, calls the tax or finance API, and stores returned identifiers. Immutable accounting records, reversal behavior, precision, and non-retryable validation errors are treated separately from transient failures.
Martini capabilities used
- workflow orchestration
- API consumption
- mapping and transformation
- financial validation
- error handling
- reconciliation
Applications commonly integrated with Certinia
Certinia can be integrated with Salesforce and adjacent enterprise applications through their APIs, files, and event mechanisms. The exact object coverage and direction depend on the Certinia products deployed, Salesforce configuration, and the target system’s data model.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| Salesforce | Certinia is Salesforce-native, so organizations commonly coordinate customer, opportunity, account, and services-delivery data across the platform. | Salesforce → Martini → Certinia | Martini consumes Salesforce REST or event APIs, validates and maps Salesforce data to Certinia package objects, and uses external IDs or correlation keys to prevent duplicate updates. |
| NetSuite | Synchronize customers, projects, billing information, invoices, and accounting results between Certinia and NetSuite. | Certinia → Martini → NetSuite | A Martini workflow retrieves approved Certinia data, transforms it into NetSuite’s API model, submits it, stores the external document identifier, and routes rejected transactions for reconciliation. |
| Workday | Exchange worker, organizational, project, time, or cost data for professional-services and payroll processes. | Workday → Martini → Certinia | Martini retrieves worker or organizational data from Workday, matches identities to Certinia Resources, applies business rules, and updates eligible records through Salesforce APIs. |
| Jira | Coordinate delivery work, project milestones, issues, and time-related information between professional-services operations and engineering teams. | Certinia → Martini → Jira | Martini synchronizes selected Projects, Assignments, and status changes with Jira issues or projects, applying identity matching, date conversion, and duplicate protection. |
| ServiceNow | Exchange customer, project, service, and operational status information between Certinia services delivery and service operations. | Certinia → Martini → ServiceNow | Martini consumes Certinia changes or scheduled extracts, maps delivery and customer information to ServiceNow records, and returns controlled status or error updates. |
| Avalara | Send invoice or transaction information for tax calculation and return tax results to support financial processing. | Certinia → Martini → Avalara | A Martini workflow retrieves eligible billing data, transforms tax-relevant fields, calls Avalara, validates returned tax values, and records the response against the source transaction. |
How to build a Certinia integration in Martini
Objective
Establish Salesforce access for the Certinia organization using an approved connected app and the least-privileged permissions required by the integration.
Instructions in Martini
- Configure the selected OAuth or JWT bearer authentication flow
- Store client secrets, certificates, tokens, and environment values in Martini secrets
- Confirm Certinia package permissions, object permissions, field-level security, and sharing access
- Separate sandbox and production configuration
Objective
Select an event, callback, API, or schedule based on the object’s supported coverage and the required delivery behavior.
Instructions in Martini
- Use Change Data Capture, Platform Events, or Outbound Messages only where verified
- Use a Martini webhook workflow for supported callbacks
- Use scheduled incremental queries when event coverage is unavailable
- Define the SystemModstamp or LastModifiedDate watermark
Objective
Obtain complete Certinia data while respecting Salesforce pagination, query selectivity, and API allocations.
Instructions in Martini
- Follow REST pagination links
- Use selective filters and deterministic watermark logic
- Use Bulk API for high-volume extraction or ingestion
- Retrieve related records and files only when required
Objective
Coordinate the end-to-end process in a Martini workflow, including enrichment, branching, asynchronous work, and status tracking.
Instructions in Martini
- Separate retrieval, transformation, target writing, and reconciliation stages
- Persist source identifiers, correlation IDs, and processing state
- Route transient and business errors to different paths
- Use asynchronous processing for long-running or bulk operations
Objective
Transform Certinia package fields into a canonical or target model while accounting for organization-specific namespaces and API names.
Instructions in Martini
- Confirm actual object and field API names from Salesforce metadata
- Map Accounts, Projects, Resources, Assignments, Timecards, and financial fields explicitly
- Validate required fields, currency, tax, dates, and approval state
- Apply external-ID and duplicate-detection rules
Objective
Create, update, or upsert target records and return controlled status information to Certinia when required.
Instructions in Martini
- Use external IDs and idempotent writes where supported
- Capture target identifiers and source-to-target relationships
- Update source processing status only after confirmed target success
- Preserve file relationships and version metadata for document transfers
Common Certinia data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Project | Represent professional-services delivery projects, dates, status, financial information, and delivery attributes. | Salesforce, Jira, Microsoft Project, NetSuite, SAP S/4HANA | Martini queries or receives Project data, confirms the organization-specific API name and namespace, maps fields, and uses external IDs for upserts. |
| Resource | Represent people or other resources allocated to professional-services work. | Workday, Jira, Microsoft Project, payroll platforms | Martini matches source identities, normalizes availability and organizational attributes, and applies ownership and permission rules before synchronization. |
| Assignment | Allocate a Resource to a Project, milestone, or work area. | Jira, Microsoft Project, workforce planning applications | Martini transforms project and resource references, handles date and timezone conversion, and applies conflict-resolution rules. |
| Timecard | Capture time submitted against Projects, Assignments, or work items. | Workday, payroll applications, NetSuite, data warehouses | Martini selects approved Timecards, maps worker and project identifiers, exports them through APIs or files, and records processing status. |
| Expense Report | Capture project-related or employee expenses submitted for approval and processing. | NetSuite, SAP S/4HANA, payroll and expense applications | Martini validates approval state, currency, tax, and line-level data, then submits eligible reports and isolates rejected lines. |
| Billing Event | Represent project billing items or events used in invoicing and revenue-related processing. | NetSuite, Avalara, SAP S/4HANA, accounting platforms | Martini retrieves approved events, applies period and financial controls, transforms the target financial model, and stores external document references. |
Authentication and security considerations
Salesforce authentication
Certinia integrations commonly use Salesforce connected apps and OAuth-based access. OAuth 2.0, JWT bearer flow, web-server flow, and other organization-approved configurations may be appropriate for different interaction models.
Permissions and secrets
Authentication does not by itself grant access to Certinia data. Connected-app scopes, profiles, permission sets, field-level security, sharing rules, API-enabled users, and Certinia package permissions all affect access.
- Store tokens, client secrets, refresh tokens, and certificates in Martini secrets or secure environment configuration.
- Use least-privileged integration users and separate sandbox and production credentials.
- Confirm package namespaces and object API names before deployment.
Operational considerations for Certinia integrations
Limits and throughput
Certinia calls consume Salesforce API allocations. Design for daily API limits, concurrent requests, Bulk API limits, event allocations, timeouts, and separate sandbox and production capacity.
Data consistency
- Follow REST pagination links and use selective queries.
- Use durable watermarks such as SystemModstamp or LastModifiedDate, while accounting for late updates, clock skew, and deleted data.
- Prefer external IDs and idempotent upserts where available.
- Separate transient errors from validation and financial-control failures.
Schema and financial controls
Certinia package upgrades can change fields and behavior. Test mappings in a sandbox and version organization-specific schemas. Financial integrations should address closed periods, currency, tax, rounding, reversals, posting status, and reconciliation.
Why use Martini instead of scripts or point-to-point integrations?
Orchestration across systems
Martini coordinates Certinia APIs, event sources, files, databases, and downstream applications in workflows rather than embedding logic in isolated scripts.
Maintainable transformations
Reusable mappings, validation, business rules, secure configuration, and controlled API exposure make organization-specific Certinia namespaces and target models easier to maintain.
Operational resilience
- Use asynchronous workflows for Bulk API jobs and long-running operations.
- Apply retries, idempotency, correlation IDs, and reconciliation for reliable processing.
- Centralize monitoring and error handling instead of duplicating them across point-to-point scripts.
Frequently asked questions
Certinia is generally integrated through the Salesforce platform because its applications are Salesforce-native. REST, SOAP, Bulk, Files, and selected Salesforce event mechanisms can support synchronization, migration, API-led orchestration, and financial processing, subject to organization permissions and package configuration.
Yes. Martini can integrate with Certinia through the Salesforce REST, SOAP, Bulk, file, and supported event or callback mechanisms available in the customer’s environment. Martini can orchestrate workflows, transform data, expose APIs, and manage validation, retries, and reconciliation.
No. A dedicated Certinia connector is not required. Martini can use Certinia’s confirmed Salesforce integration mechanisms, including REST, SOAP, Bulk, Files, OAuth authentication, and selected Salesforce event or callback endpoints.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Certinia. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Certinia, Salesforce, cloud infrastructure, or other third-party systems based on subscription, API usage, and deployment model.
REST APIs are the primary choice for individual queries and mutations, while Bulk API is appropriate for high-volume asynchronous processing. SOAP remains relevant for strongly typed or established enterprise integrations. GraphQL is only a secondary option because Certinia object and field coverage must be verified.
Certinia should not be assumed to provide a universal webhook for every business event. Salesforce Platform Events, Change Data Capture, Outbound Messages, Apex callouts, and other callbacks may support selected scenarios, depending on object support and configuration. Polling or incremental synchronization may be preferable for unsupported objects.
Martini can use event-driven workflows, API-triggered processing, or scheduled incremental queries using fields such as SystemModstamp or LastModifiedDate. It can follow pagination, use Bulk API for large volumes, map organization-specific package fields, and maintain watermarks, source identifiers, and reconciliation state.
Martini workflows can distinguish transient API failures from business validation errors, apply controlled retries and backoff, and retain correlation IDs, attempt counts, and source or target identifiers. External IDs, upserts, processed-event state, and reconciliation workflows help make retries safe and prevent duplicate processing.
Related Martini documentation
Data
Integrate Certinia with Martini
Use Martini to connect Certinia’s Salesforce-native data and event mechanisms with enterprise applications through secure APIs, workflows, mappings, and reliable synchronization.