.png)
Board Integration Guide
Integrate Board International planning and analytics models with enterprise applications through confirmed APIs, batch procedures, files, databases, and scheduled Martini workflows.
Board integration options at a glance
Board supports enterprise data integration for planning and analytics through platform capabilities, batch data loads, files, databases, and configured integration processes. Its exact REST API surface, authentication model, file formats, database drivers, and batch interfaces depend on the Board version and deployment, so these details should be confirmed in customer-specific documentation. Board does not have a publicly confirmed general-purpose webhook or GraphQL interface. Martini can consume a documented Board API, orchestrate scheduled exports or procedures, process Excel or delimited files, connect to approved database interfaces, map dimensions and measures, validate data, and route failures for retry or remediation.
| Integration point | Supported by Board? | Common use cases | How Martini supports it |
|---|---|---|---|
| REST APIs | Limited | Board provides platform integration capabilities, but the complete public REST API surface, endpoint paths, and authentication model must be confirmed for the customer’s version and deployment. | Martini can consume a documented Board REST endpoint, map responses, handle pagination where applicable, and orchestrate writes or downstream processing. |
| Bulk, asynchronous, or batch interfaces | Limited | Board supports enterprise data loading and planning workloads through batch-oriented integration processes, procedures, files, or other configured interfaces. The exact API-level contract is not publicly confirmed. | Martini can partition large workloads, schedule batch workflows, track execution identifiers, and retry failed partitions without replaying successful work. |
| File import/export | Limited | Structured files, Excel workbooks, and delimited-file exchanges may be used for controlled Board data loading and export, subject to deployment-specific formats and automation support. | Martini can process files, validate headers and values, transform dimensions and measures, archive inputs, detect duplicates, and route invalid rows for remediation. |
| Database and analytics access | Limited | Board consolidates data from enterprise databases and other data sources, but supported drivers, write semantics, and direct access to Board-managed storage depend on deployment architecture. | Martini can use approved database interfaces or staging databases, execute controlled SQL workflows, and preserve transaction, batch, and reconciliation metadata. |
| Webhooks and outbound callbacks | Not confirmed | No general-purpose Board webhook catalog covering changes, cube updates, procedure execution, or planning events was verified. Any callback is deployment-specific until documented. | Martini can receive a documented callback or webhook if Board provides one, but scheduled polling, procedures, exports, or files should be used when event delivery is unavailable. |
| GraphQL APIs | Not confirmed | No official public Board GraphQL API was confirmed in the supplied research. | Martini can consume GraphQL APIs generally, but a Board GraphQL integration should not be assumed without customer-specific documentation. |
| SOAP APIs | Not confirmed | No current official Board SOAP API was confirmed in the supplied research. | Martini supports SOAP consumption generally, but SOAP should not be selected for Board without a documented Board service contract. |
| Authentication | Limited | Board access is governed by users, roles, security profiles, applications, models, procedures, and data permissions. The exact API authentication method must be confirmed. | Martini can store environment-specific credentials in secrets, use the documented authentication method, and apply least-privilege integration identities. |
How Board exposes data and business events
Board REST APIs
Board provides platform integration capabilities through APIs, although the public endpoint catalog and authentication details were not verified. API behavior may vary by product version, model, and deployment.
Martini implementation pattern
Martini implementation pattern: Martini consumes the confirmed Board endpoint, authenticates with the documented method, retrieves or submits data, maps the response to a canonical model, and records request, batch, and model metadata.
Implementation sequence
Board batch and procedures
Board supports planning and analytics workloads that may use batch data loads, procedures, exports, or other configured integration processes. The exact interface must be confirmed for the deployment.
Martini implementation pattern
Martini implementation pattern: A scheduled workflow prepares a partitioned input, invokes the documented Board procedure or batch interface, records the execution result, and retries only failed partitions.
Implementation sequence
Board file exchange
Board implementations may use Excel and delimited files for controlled data exchange. Supported formats, locations, and automated upload mechanisms depend on the Board environment.
Martini implementation pattern
Martini implementation pattern: Martini receives or generates a controlled file, validates its schema and business keys, transforms values to the Board model, and archives the processed file with a batch ledger.
Implementation sequence
Board database exchange
Board is designed to consolidate data from enterprise databases and other sources, but drivers, schemas, transaction behavior, and write semantics are deployment-specific.
Martini implementation pattern
Martini implementation pattern: Martini stages or retrieves data through an approved database interface, applies SQL or workflow validation, and exchanges data without writing directly to Board-managed storage unless explicitly supported.
Implementation sequence
Common Board integration patterns
Pattern 1: Load ERP actuals into Board planning models
When to use this pattern
Use this pattern when financial or operational actuals from an ERP must be loaded into Board for planning, forecasting, or analysis. The workflow should validate dimensions before loading and make each period or company partition restartable.
Integration direction
Example Mapping
| Board Field | Canonical Field | Target Field |
|---|---|---|
| CompanyCode | entityCode | Entity |
| GLAccount | accountCode | Account |
| PostingPeriod | period | Period |
| Amount | measureValue | Cube measure |
Martini implementation pattern
Martini schedules extraction from SAP S/4HANA, maps account, entity, product, currency, and period codes, validates Board members and numeric precision, then loads each partition through the documented Board API, procedure, file, or approved database interface. Failed partitions are recorded for retry and rejected rows are routed for remediation.
Martini capabilities used
- workflows
- scheduled triggers
- API consumption
- data mapping
- business rules
- validation
- error handling
Pattern 2: Publish approved Board forecasts to an ERP
When to use this pattern
Use this pattern when approved Board budgets or forecasts must be returned to an ERP or financial reporting platform. Scenario, version, period, and approval status must remain explicit so working data is not confused with approved planning data.
Integration direction
Example Mapping
| Board Field | Canonical Field | Target Field |
|---|---|---|
| Scenario | scenario | BudgetScenario |
| Version | version | PlanVersion |
| Period | period | AccountingPeriod |
| MeasureValue | forecastAmount | BudgetAmount |
Martini implementation pattern
Martini receives or extracts approved Board data, checks scenario and version rules, maps dimensions and currencies, applies idempotent business keys, and submits the result to the ERP’s supported API or file interface. The workflow records the Board batch or procedure result and prevents duplicate budget submissions.
Martini capabilities used
- API exposure
- workflows
- data mapping
- business rules
- idempotency
- error handling
Pattern 3: Synchronize workforce planning data
When to use this pattern
Use this pattern when Workday or another HCM source provides employee, organization, compensation, or headcount data for Board workforce planning. Incremental processing should use a reliable modification timestamp or change token where available.
Integration direction
Example Mapping
| Board Field | Canonical Field | Target Field |
|---|---|---|
| Worker_ID | employeeCode | Employees |
| Supervisory_Organization | departmentCode | Departments |
| Cost_Center | costCenterCode | Cost Centers |
| Annualized_Compensation | compensationValue | Cube measure |
Martini implementation pattern
A scheduled Martini workflow retrieves changed Workday data, validates effective dates and organizational references, maps employees and planning dimensions to the configured Board model, and loads a controlled partition through the supported Board ingestion method. Missing members and failed partitions are reported without blocking unrelated valid data.
Martini capabilities used
- scheduled workflows
- API consumption
- incremental synchronization
- data mapping
- validation
- monitoring
Pattern 4: Distribute Board results to an analytics platform
When to use this pattern
Use this pattern when approved Board measures, planning results, or scenario snapshots must be made available to Snowflake, Power BI, or Tableau. Define whether the target receives current values, historical snapshots, detailed dimensional data, or aggregates.
Integration direction
Example Mapping
| Board Field | Canonical Field | Target Field |
|---|---|---|
| Application | boardApplication | application_name |
| Scenario | scenario | scenario |
| Version | version | version |
| CubeValue | measureValue | measure_value |
Martini implementation pattern
Martini extracts Board results through the confirmed API, procedure, file, or database path, preserves scenario and version metadata, validates row counts, and writes a governed warehouse dataset. The workflow uses batch identifiers and reconciliation checks before downstream dashboards consume the data.
Martini capabilities used
- workflows
- data extraction
- file processing
- database connectivity
- mapping
- validation
- monitoring
Applications commonly integrated with Board
Board commonly participates in enterprise planning, forecasting, performance management, and analytics architectures. The exact integration path depends on the Board deployment and the interfaces enabled in the target model; Martini can coordinate APIs, files, database exchange, validation, and scheduled processing without assuming a native Board connector.
| Application | Scenario | Direction | Martini Pattern |
|---|---|---|---|
| SAP S/4HANA | Transfer general-ledger actuals, sales, procurement, inventory, and master data into Board, and optionally return approved budgets or forecasts. | SAP S/4HANA → Martini → Board | Schedule extraction from SAP S/4HANA, map account, entity, product, currency, and period codes to Board dimensions, validate the load, and submit it through the documented Board API, procedure, file, or approved database interface. |
| Oracle ERP Cloud | Synchronize financial actuals, chart-of-accounts structures, cost centers, projects, and budgets with Board planning models. | Oracle ERP Cloud → Martini → Board | Consume the Oracle ERP Cloud API or export, apply explicit dimension mappings and validation rules, partition the data by period or business unit, and invoke the approved Board ingestion method with restartable processing. |
| Microsoft Dynamics 365 Finance | Consolidate financial and operational data in Board for budgeting, forecasting, and management reporting. | Microsoft Dynamics 365 Finance → Martini → Board | Retrieve Dynamics 365 data incrementally where supported, normalize codes and numeric values, validate required Board members, and load accepted partitions through the confirmed Board interface while recording rejected rows. |
| Workday | Bring workforce, compensation, organizational, and headcount data into Board workforce planning models. | Workday → Martini → Board | Run a scheduled workflow that retrieves Workday data, maps employees, departments, cost centers, and hierarchies to the configured Board model, validates effective dates, and loads changes using the supported Board procedure or file process. |
| Salesforce | Combine pipeline, bookings, customer, and sales data with Board financial planning and forecasting. | Salesforce → Martini → Board | Consume Salesforce data through its supported API, transform sales measures and organizational codes, apply scenario and period rules, and deliver the prepared dataset through a Board-supported API, file, or database exchange. |
| Snowflake | Centralize Board planning outputs or combine Board data with enterprise warehouse data for analytics and reporting. | Board → Martini → Snowflake | Extract approved Board measures or dimensional results using the confirmed export, API, procedure, or database path, normalize snapshots and scenario metadata, and write governed datasets to Snowflake with batch identifiers. |
| Microsoft Power BI | Present Board planning, forecast, and performance data alongside operational reporting. | Board → Martini → Microsoft Power BI | Extract Board results into a warehouse, file, or API-mediated dataset, preserve scenario and version fields, validate refresh completeness, and publish through the supported Power BI data architecture. |
| Tableau | Distribute Board planning and performance data to governed analytical dashboards. | Board → Martini → Tableau | Create a scheduled Board extraction workflow, shape dimensional and aggregated data for the reporting model, archive the source batch, and deliver it to Tableau through the approved intermediate platform or file/API route. |
How to build a Board integration in Martini
Objective
Establish the Board interface and authentication contract for the target version, deployment, application, model, procedure, file exchange, or database path.
Instructions in Martini
- Confirm the Board endpoint, deployment type, model names, supported interface, and network requirements.
- Create a dedicated least-privilege Board integration identity with only the required application, model, procedure, and data permissions.
- Store credentials and environment-specific values in Martini secrets or configuration rather than workflow definitions.
Objective
Select a trigger that reflects Board’s confirmed capabilities and the business freshness requirement.
Instructions in Martini
- Use a scheduled workflow for polling, exports, procedures, and batch loads when no verified Board event facility is available.
- Use a documented Board callback only after confirming event types, payloads, delivery guarantees, retries, and authentication.
- Partition scheduled work by company, period, scenario, model, or another stable business boundary.
Objective
Acquire Board or source-system data through the documented API, procedure, file, or approved database interface.
Instructions in Martini
- Retrieve data incrementally when a reliable timestamp, change token, procedure execution identifier, or batch identifier exists.
- Process pages, files, or partitions incrementally to avoid unnecessary memory use.
- Capture request identifiers, source batch identifiers, application names, model names, and procedure names.
Objective
Coordinate extraction, validation, transformation, loading, reconciliation, and recovery as an explicit Martini workflow.
Instructions in Martini
- Separate transport, transformation, validation, loading, and reconciliation stages.
- Persist checkpoints and integration ledger entries so successful partitions are not replayed unintentionally.
- Route invalid rows and failed partitions to operational handling without silently discarding data.
Objective
Convert source fields and codes into the configured Board entities, cubes, measures, scenarios, versions, and periods, or into the target application model.
Instructions in Martini
- Use explicit mapping tables for account, entity, product, employee, cost center, currency, and period codes.
- Apply numeric precision, sign, aggregation, hierarchy, and effective-date rules.
- Validate required members and preserve scenario, version, application, and model context.
Objective
Enforce planning, approval, idempotency, and data-quality rules before committing a load or publishing results.
Instructions in Martini
- Use deterministic keys such as Scenario, Version, Period, Entity, Account, Product, and Currency.
- Determine whether the operation inserts, updates, replaces, appends, or invokes a Board procedure.
- Reject or quarantine data with missing dimensions, invalid hierarchies, duplicate batches, or unauthorized targets.
Common Board data objects used in integrations
| Object | Typical Use | Common target systems | Martini handling |
|---|---|---|---|
| Applications | Board planning, forecasting, reporting, and analytics applications that provide the business context for an integration. | SAP S/4HANA, Oracle ERP Cloud, Microsoft Dynamics 365 Finance, Power BI, Tableau | Martini carries the configured application identifier as metadata, validates that the target application is permitted, and routes data to the appropriate model or procedure. |
| Entities | Business dimensions such as Products, Customers, Employees, Cost Centers, Accounts, and Regions. | ERP platforms, Workday, Salesforce, Snowflake | Martini maps source codes and hierarchies to the specific Board entity members, validates required and inactive members, and processes master data before measures. |
| Cubes | Multidimensional structures containing measures and values across Board dimensions. | ERP platforms, data warehouses, Power BI, Tableau | Martini preserves dimensional keys, scenario, version, period, currency, and measure semantics while applying configured load, replace, append, or procedure rules. |
| Procedures | Reusable Board logic for data loading, calculations, allocations, transformations, and other operations. | Martini workflows, ERP platforms, files, databases | Martini invokes a documented procedure where supported, records execution results, partitions inputs, and prevents duplicate execution through batch identifiers and checkpoints. |
| Data sources | External files, databases, applications, or other systems from which Board receives data. | SAP S/4HANA, Oracle ERP Cloud, Workday, Snowflake, file repositories | Martini orchestrates extraction or delivery, validates source batches and schemas, transforms data, and uses the Board-supported ingestion path rather than assuming direct storage writes. |
| Users and security profiles | Identities, roles, and permissions controlling access to Board applications and data. | Identity platforms, HR systems, administration processes | Martini treats security assignments as controlled administrative data, uses least-privilege credentials, and does not bypass Board authorization or security configuration. |
Authentication and security considerations
Authentication and access
Board access is governed by users, roles, security profiles, applications, models, procedures, and data permissions. The exact authentication method for an external API or interface must be confirmed for the target deployment.
- Use a dedicated Board integration identity with least-privilege access.
- Store credentials in Martini secrets or environment configuration.
- Confirm cloud or self-managed network access, firewall rules, endpoint allowlisting, and deployment-specific requirements.
- Do not assume OAuth 2.0, API keys, or service credentials without Board documentation.
Operational considerations for Board integrations
Reliability and operations
Board models are configurable, and API behavior, schemas, procedures, and permissions can change with the deployment. Treat the Board model and interface contract as governed integration dependencies.
- Confirm pagination, page sizes, request limits, concurrency, and capacity before production loads.
- Use watermarks, period or scenario partitions, deterministic business keys, and batch identifiers for incremental and idempotent processing.
- Validate dimensions, hierarchies, currencies, precision, signs, and aggregation behavior before loading.
- Partition large loads and persist execution results so failed partitions can be retried independently.
- For files, validate encoding, delimiters, headers, naming, duplicate files, archival, and retention.
- Monitor model changes, missing members, renamed procedures, security changes, response status, counts, and reconciliation results.
Why use Martini instead of scripts or point-to-point integrations?
Integration control and maintainability
Board integrations often combine configurable planning models with enterprise APIs, files, databases, and scheduled processing. Martini provides a governed workflow layer instead of embedding fragile point-to-point logic in scripts or individual applications.
- Centralize authentication, secrets, mappings, validation, business rules, and environment configuration.
- Orchestrate API calls, procedures, files, database exchange, retries, checkpoints, and reconciliation in one maintainable workflow.
- Expose a controlled API façade when downstream systems should not depend directly on Board-specific interfaces.
- Reuse canonical mappings and processing services across applications, models, periods, and scenarios.
- Provide operational logging and error handling while avoiding unnecessary exposure of credentials or sensitive planning data.
Frequently asked questions
Board can be integrated through its confirmed deployment-specific APIs, batch or procedure-based processes, structured files, and approved database or data-source interfaces. Common flows include loading ERP and workforce data into Board and distributing approved planning results to warehouses or reporting platforms. Exact endpoints, formats, authentication, and write semantics must be verified for the Board version and model.
Yes. Martini can integrate with Board by consuming a documented Board API, orchestrating scheduled procedures or exports, processing Excel or delimited files, and using an approved database interface. Martini can map dimensions and measures, validate loads, expose APIs for downstream submissions, and handle reconciliation and retries.
No. A dedicated Board connector is not required. Martini can use Board’s confirmed native APIs, file interfaces, database access methods, batch procedures, or deployment-specific callbacks through workflows and API integrations. No native Martini Board connector is documented in the supplied sources.
Lonti does not charge an additional per-connector or per-vendor fee to integrate Board. The integration is subject to the provisioned capacity of the Martini environment. Separate costs may apply from Board, cloud infrastructure, or other third-party systems depending on subscription, usage, and deployment model.
Use a documented Board REST endpoint, batch or procedure interface, controlled file exchange, or approved database integration according to the deployment and workload. REST and batch-oriented methods are primary candidates, while files and database exchange can suit controlled bulk processing. GraphQL and SOAP should not be assumed because neither was publicly confirmed.
A general-purpose Board webhook framework was not confirmed. Do not assume that changes to entities, cubes, procedures, or planning data generate notifications. A documented deployment-specific callback can be used if its event coverage, payload, authentication, delivery, and retry behavior are verified; otherwise use scheduled polling, exports, procedures, or files.
Martini can use scheduled workflows, watermarks, period or scenario extracts, batch identifiers, and integration ledgers to synchronize Board data. Explicit mappings and validation should account for configurable entities, cubes, dimensions, procedures, hierarchies, numeric precision, and security permissions. Model changes should be tested in a non-production environment before release.
Yes. Martini can expose a controlled REST API that accepts approved forecasts, budgets, or planning submissions, applies authentication and business rules, maps the payload to the Board model, and invokes the documented Board ingestion method. This can shield consumers from deployment-specific Board interfaces while centralizing validation and error handling.
Related Martini documentation
Workflows
Integrate Board with Martini
Use Martini to connect Board planning and analytics models with enterprise applications through governed APIs, workflows, files, databases, validation, and scheduled data synchronization.