Ellipse Gradient for Header

Sage People Integration Guide

Sage People integrates with enterprise systems through Salesforce-based REST APIs, OAuth 2.0, scheduled synchronization, and selectively available event or callback mechanisms.

Sage People integration options at a glance

Sage People primarily supports Salesforce-based REST API integration for reading and updating Person, Employment, Position, Organization, Absence, and related data. OAuth 2.0 provides the expected authentication model, with access controlled by connected-app scopes, object permissions, field-level security, and sharing rules. Salesforce bulk and asynchronous capabilities may support larger synchronizations when enabled for the customer’s environment. Webhook-style notifications, platform events, outbound messages, or change notifications may be available for selected objects and configurations, but coverage must be verified. Martini can consume these APIs, receive supported callbacks, schedule incremental queries, transform HR data, and expose controlled APIs to downstream systems.

Integration pointSupported by Sage People?Common use casesHow Martini supports it
REST APIsYesRead and update Person, Employment, Position, Organization, and Absence data; run filtered queries and orchestrate HR workflows.Martini can consume authenticated Sage People or Salesforce REST endpoints, map responses, apply business rules, and expose transformed data through Martini APIs.
AuthenticationYesOAuth 2.0 connected-app authentication with access tokens and, where configured, refresh tokens; permissions and sharing rules constrain access.Martini stores OAuth credentials and environment-specific endpoints in secure configuration or secrets and uses them from workflows.
Webhooks / outbound callbacksLimitedSalesforce platform events, outbound messages, change notifications, or other callbacks may notify selected object changes when configured.Martini can receive supported callback or event requests, validate them, retrieve current Sage People data, and route them into workflows; coverage must be verified per object.
Bulk / async / batch APIsLimitedLarge Person, Employment, or Absence synchronizations may use Salesforce bulk or asynchronous capabilities where enabled and suitable for managed-package objects.Martini can orchestrate batch extraction, staging, pagination, transformation, and reconciliation while handling partial failures.
File / attachment APIsLimitedSalesforce Files, legacy Attachments, or a Sage People-specific document model may expose HR documents, subject to permissions and customer configuration.Martini can process confirmed file or content endpoints and apply content-type, privacy, retention, and transfer rules.
Scheduled synchronizationYesIncremental polling is appropriate when event coverage is unavailable or incomplete, using a last-modified field or equivalent checkpoint.Martini scheduler-triggered workflows can query pages of changed objects, commit checkpoints after successful processing, and provide reconciliation logs.
Database / analytics accessNoDirect SQL access is not a normal Sage People integration mechanism; supported APIs or approved exports should be used.Martini can write API results to an approved database or reporting store, but it should not connect directly to the Sage People SaaS database.

How Sage People exposes data and business events

Sage People REST APIs

REST is the primary confirmed integration mechanism for Sage People. Because the product is built on Salesforce, the applicable API version, tenant host, managed-package object names, fields, and permissions must be confirmed in the customer environment.

Martini implementation pattern

Martini implementation pattern: a workflow authenticates with OAuth 2.0, calls filtered Sage People or Salesforce REST endpoints, handles pagination, maps the response into a canonical model, applies HR lifecycle rules, and writes to one or more targets.

Implementation sequence

Authenticate with the configured OAuth 2.0 credentials
Retrieve the required Sage People object pages
Normalize and validate the response fields
Apply lifecycle and data-ownership rules
Write idempotently to the target system
Commit the checkpoint and record the outcome

Scheduled synchronization

Scheduled incremental synchronization is the recommended fallback when event coverage is unavailable or incomplete. The workflow should use a reliable last-modified field or equivalent change marker and avoid unbounded workforce queries.

Martini implementation pattern

Martini implementation pattern: a scheduler starts the workflow, the workflow loads the last successful checkpoint, retrieves changed Person, Employment, Absence, or related objects in pages, processes each item, and advances the checkpoint only after successful handling.

Implementation sequence

Start the workflow on a controlled schedule
Load the last successful synchronization checkpoint
Query changed records in bounded pages
Transform and process each page idempotently
Retry transient failures and isolate permanent failures
Persist the new checkpoint after successful completion

Outbound callbacks and events

Salesforce-based event mechanisms such as platform events, outbound messages, or change notifications may be available for selected Sage People objects and configurations. Sage People should not be described as providing unrestricted webhooks for every business event.

Martini implementation pattern

Martini implementation pattern: Martini receives a supported notification, validates its origin and payload, retrieves the current Sage People resource when necessary, and invokes the same reusable mapping and target-writing logic used by scheduled reconciliation.

Implementation sequence

Receive the supported Sage People or Salesforce notification
Validate the request and identify the source object
Retrieve the current resource when the notification is incomplete
Apply the canonical mapping and business rules
Write the target result idempotently
Run scheduled reconciliation for missed or unsupported events

Bulk and asynchronous APIs

Salesforce bulk and asynchronous capabilities may support larger Sage People synchronizations, subject to customer edition, API entitlement, managed-package object support, and data volume.

Martini implementation pattern

Martini implementation pattern: Martini submits or orchestrates bounded extraction work, monitors completion, stages results, transforms records in batches, and produces reconciliation and partial-failure outcomes rather than treating a batch as all-or-nothing without verification.

Implementation sequence

Confirm bulk or asynchronous support for the required objects
Submit a bounded extraction or batch request
Monitor completion and retrieve the results
Stage and transform the returned records
Retry transient batch failures and report rejected rows
Reconcile counts and source identifiers

Common Sage People integration patterns

Pattern 1: Synchronize employees to identity and service systems

When to use this pattern

Use this pattern when Person and Employment data drives joiner, mover, and leaver processes. It supports scheduled polling or a verified event mechanism and coordinates identity provisioning, access changes, and operational requests.

Integration direction
Sage People
Martini
Microsoft Entra ID
ServiceNow
Example Mapping
Sage People FieldCanonical FieldTarget Field
Person identifierperson.sourceIdexternal worker ID
Employment statusemployment.lifecycleStatusaccount action
Positionassignment.positionjob title or request context
Organizationassignment.organizationdepartment or assignment group
Martini implementation pattern

Martini retrieves changed Person, Employment, Position, and Organization data, validates lifecycle state and effective dates, routes new hires, movers, and leavers, and performs idempotent target updates. Failed target calls are retried when transient and retained for operational review when validation or authorization fails.

Martini capabilities used
  • workflows
  • API consumption
  • scheduling
  • data mapping
  • business rules
  • error handling

Pattern 2: Synchronize approved absences to downstream systems

When to use this pattern

Use this pattern when approved leave or amended Absence data must reach payroll, workforce scheduling, reporting, or service-management applications. The workflow should explicitly handle the customer’s available status model.

Integration direction
Sage People
Martini
Payroll or scheduling application
Example Mapping
Sage People FieldCanonical FieldTarget Field
Absence identifierabsence.sourceIdleave record ID
Absence statusabsence.statusapproval state
Start and end datesabsence.startDate / absence.endDateleave period
Person identifierperson.sourceIdworker reference
Martini implementation pattern

Martini retrieves changed Absence records, joins them with the required Person identifiers, maps status and date representations, filters records according to approval rules, and upserts the target. Checkpoints and source identifiers prevent duplicates during retries or amended leave processing.

Martini capabilities used
  • workflows
  • API consumption
  • data mapping
  • validation
  • business rules
  • idempotency

Pattern 3: Export and reconcile HR data

When to use this pattern

Use this pattern for controlled reporting, warehouse loading, migration, or reconciliation across Person, Employment, Position, Organization, and Absence data.

Integration direction
Sage People
Martini
Data warehouse or controlled file exchange
Example Mapping
Sage People FieldCanonical FieldTarget Field
Personworkerworker dimension
Employmentemploymentemployment fact
Organizationorganizationorganizational dimension
Absenceabsenceabsence fact
Martini implementation pattern

A scheduled Martini workflow paginates through confirmed API resources, normalizes Salesforce package-specific fields, generates structured output or writes to a target store, detects missing and duplicate source identifiers, and records reconciliation totals. Partial failures are isolated so successful pages are not discarded.

Martini capabilities used
  • scheduling
  • API consumption
  • pagination orchestration
  • data mapping
  • JSON and file transformation
  • monitoring

Pattern 4: Event-assisted HR lifecycle automation

When to use this pattern

Use this pattern when the customer has configured a supported platform event, outbound message, change notification, or callback for a required Sage People object and wants lower-latency processing than polling alone.

Integration direction
Sage People
Martini
Downstream applications
Example Mapping
Sage People FieldCanonical FieldTarget Field
Notification object IDevent.sourceIdcorrelation key
Changed object typeevent.objectTypeworkflow route
Employment statusemployment.lifecycleStatusbusiness action
Position or Organizationassignmentaccess or task routing
Martini implementation pattern

Martini receives and validates the supported notification, retrieves the current resource to avoid relying on incomplete event data, invokes reusable transformation and business-rule logic, and writes idempotently to downstream applications. A scheduled reconciliation workflow covers missed or unsupported events.

Martini capabilities used
  • workflow triggers
  • webhook consumption
  • API consumption
  • routing
  • data mapping
  • error handling

Applications commonly integrated with Sage People

Sage People commonly participates in workforce identity, HR service, finance, payroll, and collaboration processes. The following are practical enterprise integration targets; exact ownership, direction, and supported fields should be confirmed for each customer environment.

Application Scenario Direction Martini Pattern
Salesforce Sage People is built on Salesforce, so organizations may synchronize Sage People data with Salesforce applications, custom objects, or other Salesforce-based processes. Sage People → Martini → Salesforce Martini consumes the applicable Sage People REST endpoints, maps managed-package object fields to Salesforce targets, applies field-level business rules, and performs idempotent create-or-update operations with retry handling.
Microsoft Entra ID Employment status, worker identity, position, and organization changes can support identity provisioning, access updates, and deprovisioning. Sage People → Martini → Microsoft Entra ID A scheduled or supported event-driven workflow retrieves changed Person and Employment data, evaluates lifecycle rules, and calls the target identity API while recording source and target identifiers.
ServiceNow Worker lifecycle changes can create onboarding, offboarding, access, and HR service requests for operational teams. Sage People → Martini → ServiceNow Martini maps Employment, Position, and Organization changes into ServiceNow request payloads, routes exceptions for review, and can reconcile request status through a controlled reverse flow.
Workday Organizations operating both HR platforms may reconcile worker, employment, organizational, or payroll-related information. Sage People → Martini → Workday Martini establishes field-level ownership, retrieves incremental changes from each platform, normalizes worker and employment models, and applies conflict and duplicate-prevention rules.
NetSuite Worker and organizational information may support finance, expense, payroll, and workforce-related processes. Sage People → Martini → NetSuite A Martini workflow extracts approved Sage People data, transforms it into NetSuite-compatible payloads, validates required fields, and retries transient target failures without duplicating records.
Jira Onboarding and offboarding changes can create or update work items for HR and IT teams. Sage People → Martini → Jira Martini detects relevant Employment or Position changes, applies routing rules, creates Jira issues, and stores correlation identifiers for subsequent updates.
Sage 50 Payroll Customers operating both Sage People and a Sage payroll product may need to transfer employee or employment-related information. Sage People → Martini → Sage 50 Payroll Martini extracts the agreed Person and Employment fields, transforms them into the supported payroll exchange format, validates payroll-specific values, and produces reconciliation results.
Microsoft Teams Employee lifecycle or organizational updates may support collaboration workflows and targeted operational notifications. Sage People → Martini → Microsoft Teams Martini filters approved organizational changes, transforms them into Microsoft Graph or collaboration workflow requests, and applies privacy rules to avoid unnecessary HR data disclosure.

How to build a Sage People integration in Martini

Objective

Establish the customer-specific Sage People or Salesforce API host, API version, object API names, and OAuth 2.0 configuration before building mappings.

Instructions in Martini

  • Confirm the tenant endpoint and API version
  • Create or identify the permitted connected-app configuration
  • Store client credentials, tokens, and endpoints in Martini secrets or environment configuration
  • Verify object, field, sharing, and field-level permissions

Objective

Select the lowest-latency mechanism that is actually available for the required Sage People objects, while retaining scheduled reconciliation.

Instructions in Martini

  • Use a supported callback or event only after confirming object coverage
  • Otherwise use a scheduler trigger for incremental REST queries
  • Define the last-modified field or equivalent change marker
  • Set an appropriate polling interval and concurrency limit

Objective

Retrieve the required Person, Employment, Position, Organization, Absence, or Job History resources efficiently and safely.

Instructions in Martini

  • Request only the fields required by the integration
  • Use bounded queries and pagination
  • Persist source identifiers and synchronization checkpoints
  • Use bulk or asynchronous APIs only when enabled and appropriate

Objective

Build a reusable Martini workflow that separates retrieval, normalization, business decisions, target delivery, and operational handling.

Instructions in Martini

  • Route records by object and lifecycle state
  • Join related Person and Employment data where needed
  • Separate transient failures from validation and authorization failures
  • Reuse common mapping and target-writing logic

Objective

Transform Sage People’s customer-specific Salesforce object model into canonical payloads and target-specific structures.

Instructions in Martini

  • Confirm managed-package API names rather than relying on screen labels
  • Normalize dates, statuses, identifiers, and organizational values
  • Preserve source and target correlation identifiers
  • Exclude unnecessary sensitive HR fields

Objective

Apply HR lifecycle, authority, privacy, and data-quality rules before writing to downstream systems.

Instructions in Martini

  • Define handling for future-dated employment, rehires, transfers, and termination
  • Distinguish approved, rejected, cancelled, and amended Absence states where available
  • Validate required target fields and permitted status values
  • Prevent duplicate creates during retries

Common Sage People data objects used in integrations

ObjectTypical UseCommon target systemsMartini handling
PersonWorker or individual demographic and identity information used for employee master synchronization.Microsoft Entra ID, ServiceNow, Salesforce, Workday, payroll platformsMartini retrieves the confirmed customer-specific object and field names, removes unnecessary sensitive fields, maps to a canonical person model, and preserves source identifiers.
EmploymentEmployment relationship, start date, end date, status, and employment attributes used for lifecycle automation.Microsoft Entra ID, ServiceNow, payroll platforms, NetSuiteMartini applies joiner, mover, and leaver rules, validates dates and statuses, and performs idempotent downstream updates.
PositionRole, position, job, or assignment information used for access, organizational, and workforce processes.Salesforce, Microsoft Entra ID, ServiceNow, WorkdayMartini maps position and assignment fields, applies routing rules, and correlates changes with the related Person and Employment records.
OrganizationDepartments, divisions, teams, or business units used for reporting, access, and workflow routing.Salesforce, Microsoft Teams, ServiceNow, NetSuiteMartini normalizes organizational identifiers and hierarchy values, validates references, and synchronizes only the fields required by each target.
AbsenceLeave, absence, or time-off information used for payroll, scheduling, availability, and reconciliation.Payroll platforms, workforce scheduling systems, ServiceNow, reporting storesMartini retrieves confirmed Absence fields, distinguishes available status values such as approved or cancelled, and synchronizes changes idempotently.
Job HistoryHistorical changes to a worker’s job, position, manager, or organizational assignment.Data warehouses, reporting stores, Salesforce, audit processesMartini paginates historical data, converts it into a canonical change model, and preserves effective dates and source identifiers.

Authentication and security considerations

OAuth-based access

Sage People integrations generally use the Salesforce authentication model. OAuth 2.0 with access tokens is the preferred approach for new server-to-server integrations, with refresh tokens used where the configured authorization flow permits them.

Least-privilege permissions

Access is constrained by connected-app scopes, integration-user permissions, Sage People object access, field-level security, sharing rules, and the customer’s tenant configuration. Confirm the exact managed-package objects and fields before deployment.

Protect HR data

  • Store OAuth credentials, access tokens, and refresh tokens in Martini secrets or secure environment configuration.
  • Transfer only the Person, Employment, Absence, and related fields required by the business process.
  • Apply additional privacy and retention controls to absence details and HR documents.
  • Use the correct Sage People or Salesforce login and API host for each environment.

Operational considerations for Sage People integrations

API limits and pagination

Use selective, bounded queries and pagination for Person, Employment, Absence, and other collections. Salesforce API limits may be shared across users and integrations, so control concurrency and use backoff when throttled.

Checkpoints and idempotency

Persist a reliable last-modified checkpoint and advance it only after successful processing. Use stable source IDs or customer-defined external IDs so retries do not create duplicate employees, positions, or absence records.

Events and reconciliation

Do not assume every Sage People change generates a callback. Verify event coverage per object and retain scheduled incremental reconciliation even when event-driven processing is available.

Schema and package changes

Managed-package upgrades can affect API versions, fields, required values, validation rules, and status semantics. Test mappings in a representative non-production environment and monitor for schema or permission changes.

Testing and monitoring

  • Test future-dated employment, rehires, transfers, concurrent assignments, terminations, and amended Absence records.
  • Monitor response status, page counts, rejected records, checkpoint movement, and reconciliation totals.
  • Retry transient failures with controlled backoff and route permanent failures for review.
  • Confirm document and file permissions before transferring Salesforce Files or legacy Attachments.

Why use Martini instead of scripts or point-to-point integrations?

Reusable orchestration

Martini separates API retrieval, mapping, business rules, target delivery, and error handling into maintainable workflows rather than embedding all logic in a one-off script.

Reliable synchronization

Scheduled triggers, supported event intake, pagination, checkpoints, idempotent writes, retries, and reconciliation provide a controlled operating model for sensitive HR data.

Flexible integration surface

Martini can consume Sage People REST APIs, transform customer-specific Salesforce package objects, write to multiple downstream systems, and expose a controlled API façade when consumers should not access Sage People directly.

Operational control

  • Centralize secure credentials and environment-specific configuration.
  • Apply consistent validation, privacy, routing, and lifecycle rules.
  • Monitor workflows and investigate partial failures without discarding successful records.
  • Extend mappings or business logic when customer-specific Sage People configuration requires it.

Frequently asked questions

How can Sage People be integrated with enterprise systems?

Sage People can be integrated primarily through its Salesforce-based REST APIs using OAuth 2.0. Enterprise workflows can retrieve and update Person, Employment, Position, Organization, Absence, and related data, while selected Salesforce-based event or callback mechanisms may support lower-latency notifications. Scheduled incremental synchronization remains appropriate when event coverage is incomplete.

Can Martini integrate with Sage People?

Yes. Martini can consume Sage People or Salesforce REST APIs, authenticate with OAuth 2.0, orchestrate workflows, transform Sage People objects, and expose controlled APIs for downstream applications. It can also receive a supported callback or event when the customer has configured one for the required object.

Do I need a connector to integrate Sage People with Martini?

No. A dedicated Sage People connector is not required. Martini can use Sage People’s confirmed native integration mechanisms, including REST APIs, OAuth 2.0, scheduled queries, and supported Salesforce-based callbacks or asynchronous APIs.

Is there any extra Lonti cost to integrate Sage People with Martini?

Lonti does not charge an additional per-connector or per-vendor fee to integrate Sage People. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Sage, infrastructure providers, or other third-party systems depending on subscriptions, usage, and deployment model.

Which Sage People integration method should be used?

REST APIs with OAuth 2.0 are the primary choice for new integrations. Bulk or asynchronous APIs may suit larger volumes when enabled for the customer’s objects. Callback and event mechanisms can be used selectively after verifying object coverage. GraphQL is not confirmed, and a current Sage People-specific SOAP endpoint was not verified.

Are Sage People webhooks or events available for all changes?

No unrestricted event coverage should be assumed. Salesforce platform events, outbound messages, change notifications, or similar mechanisms may be available for selected objects and configurations. Confirm the required Person, Employment, Position, Organization, or Absence event individually, and use scheduled incremental synchronization as a fallback and reconciliation process.

How does synchronization and data mapping work?

Martini can retrieve changed Sage People objects in pages, map customer-specific Salesforce package fields into canonical models, apply lifecycle and privacy rules, and write idempotently to target applications. A persisted checkpoint, stable source identifier, and target correlation key support incremental processing and reconciliation.

How are errors, retries, and duplicate records handled?

Workflows can distinguish transient network, throttling, or server errors from validation and authorization failures. Transient failures can be retried with controlled backoff, while permanent failures are logged for review. Stable Sage People or Salesforce IDs, external IDs, checkpoints, and idempotent upserts help prevent duplicate employees, positions, or Absence records.

Can Martini expose an API façade for Sage People?

Yes. Martini can expose a controlled REST API that retrieves or serves transformed Sage People data. This allows centralized authentication, filtering, validation, authorization, and business rules without exposing Sage People directly to every downstream application.

Related Martini documentation

Martini APIs

Workflows

Security

Operations

Connect Sage People with your enterprise systems

Use Martini to build secure, maintainable Sage People integrations around REST APIs, OAuth 2.0, workflows, scheduled synchronization, supported events, and controlled API access.

EXPLORE MARTINI
BOOK A DEMO